#include "colision.h"


//--------------------------------------------------------------------------------------------/
bool colision::colisionSegmentoHorizontal(punto puntoHorizontaInicial, punto puntoHorizontaFinal, punto puntoInicial,punto puntoFinal, punto* puntos)
{
	float pendiente, ordenada, respuestaX, respuestaY;
	bool tipoRecta;

	tipoRecta = obtenerPendienteORdenada(puntoInicial.getX(),puntoInicial.getY(),puntoFinal.getX(),puntoFinal.getY(),&pendiente,&ordenada);

	if(!tipoRecta)
	{
		respuestaX = puntoInicial.getX();
		respuestaY = puntoHorizontaInicial.getY();
	}

	else
	{
		respuestaX = (puntoHorizontaInicial.getY() - ordenada) / pendiente;
		respuestaY = pendiente * respuestaX + ordenada;
	}

	if(verificaSiEstaEnRecta(puntoInicial.getX(),puntoInicial.getY(),puntoFinal.getX(),puntoFinal.getY(),respuestaX,respuestaY) &&verificaSiEstaEnRecta(puntoHorizontaInicial.getX(),puntoHorizontaInicial.getY(),puntoHorizontaFinal.getX(),puntoHorizontaFinal.getY(),respuestaX,respuestaY))
	{
		puntos->setX(respuestaX);
		puntos->setY(respuestaY);
		return true;
	}
	else
		return false;

}

//--------------------------------------------------------------------------------------------/

//usado en tejo
bool colision::colisionSegmentoVertical(punto puntoVerticalInicial, punto puntoVerticalFinal, punto puntoInicial,punto puntoFinal, punto* puntos)
{
	float pendiente, ordenada, respuestaX, respuestaY;
	bool tipoRecta;

	tipoRecta = obtenerPendienteORdenada(puntoInicial.getX(),puntoInicial.getY(),puntoFinal.getX(),puntoFinal.getY(),&pendiente,&ordenada);

	if(!tipoRecta)
	{
		return false;
	}

	else
	{
		respuestaX = puntoVerticalInicial.getX();
		respuestaY = pendiente * respuestaX + ordenada;
	}

	if(verificaSiEstaEnRecta(puntoInicial.getX(),puntoInicial.getY(),puntoFinal.getX(),puntoFinal.getY(),respuestaX,respuestaY) &&	verificaSiEstaEnRecta(puntoVerticalInicial.getX(),puntoVerticalInicial.getY(),puntoVerticalFinal.getX(),puntoVerticalFinal.getY(),respuestaX,respuestaY))
	{
		puntos->setX(respuestaX);
		puntos->setY(respuestaY);
		return true;
	}
	else
		return false;

}
//--------------------------------------------------------------------------------------------/

//usado arriba
bool colision::obtenerPendienteORdenada(float x1, float y1, float x2, float y2,	float *pendiente, float *ordenada)
{
	float x, y, z;

	x = x2 - x1;
	y = y2 - y1;

	if (x != 0)
		*pendiente = y / x;
	else
		return false;

	z = -x1 / x;

	*ordenada = (z * y) + y1;

	return true;
}
//--------------------------------------------------------------------------------------------/


bool colision::verificaSiEstaEnRecta(float x1, float y1, float x2, float y2,float respuestaX, float respuestaY)
{
	int estadoUno, estadoDos, estadoGeneral;
	estadoUno = estadoDos = estadoGeneral = false;

	if ((x1 >= respuestaX && x2 <= respuestaX) || (x2 >= respuestaX && x1 <= respuestaX))
		estadoUno = true;

	if ((y1 >= respuestaY && y2 <= respuestaY) || (y2 >= respuestaY && y1 <= respuestaY))
		estadoDos = true;

	if (estadoUno && estadoDos)
		estadoGeneral = true;

	return estadoGeneral;
}
//--------------------------------------------------------------------------------------------/

bool colision::colisionRectas(float ordenada, punto puntoDosInicial, punto puntoDosFinal, punto* puntos)
{
	float segundaPendiente, SegundaOrdenada;
	int tipoRecta;
	float nuevoX, nuevoY;

	tipoRecta = obtenerPendienteORdenada(puntoDosInicial.getX(), puntoDosInicial.getY(), puntoDosFinal.getX(),	puntoDosFinal.getY(), &segundaPendiente, &SegundaOrdenada);

	if (tipoRecta == 0)
	{
		nuevoX = puntoDosInicial.getX();
		nuevoY = ordenada;
		puntos->setX(nuevoX);
		puntos->setY(nuevoY);
	}

	else
	{
		if (segundaPendiente == 0)
			return false;
		nuevoX = (SegundaOrdenada - ordenada) / (-segundaPendiente);
		nuevoY = ordenada;
		puntos->setX(nuevoX);
		puntos->setY(nuevoY);
	}

	if (verificaSiEstaEnRecta(puntoDosInicial.getX(), puntoDosInicial.getY(), puntoDosFinal.getX(),	puntoDosFinal.getY(), puntos->getX(), puntos->getY()))
		return true;
	else
		return false;
}
//--------------------------------------------------------------------------------------------/

//usado en el triangulo

bool colision::colisionSegmentoRecta(punto puntoRectaA, punto puntoRectaB, punto puntoSegmentoA,punto puntoSegmentoB, float* pendiente, float* ordenada, punto* puntos)
{
	bool resultadoA, resultadoB;
	float segundaPendiente, segundaOrdenada;

	resultadoA = obtenerPendienteORdenada(puntoRectaA.getX(), puntoRectaA.getY(), puntoRectaB.getX(), puntoRectaB.getY(),&segundaPendiente, &segundaOrdenada);
	resultadoB = obtenerPendienteORdenada(puntoSegmentoA.getX(), puntoSegmentoA.getY(), puntoSegmentoB.getX(), puntoSegmentoB.getY(),pendiente, ordenada);

	if (!resultadoA && !resultadoB)
		return false;

	else if (!resultadoA && resultadoB)
	{
		puntos->setX(puntoRectaA.getX());
		puntos->setY(*pendiente * puntoRectaA.getX() + *ordenada);

		if (verificaSiEstaEnRecta(puntoSegmentoA.getX(), puntoSegmentoA.getY(), puntoSegmentoB.getX(), puntoSegmentoB.getY(),puntos->getX(), puntos->getY()))
			return true;
		else
			return false;
	} else if (resultadoA && !resultadoB)
	{
		puntos->setX(puntoSegmentoA.getX());
		puntos->setY(segundaPendiente * puntoSegmentoA.getX() + segundaOrdenada);
		if (verificaSiEstaEnRecta(puntoSegmentoA.getX(), puntoSegmentoA.getY(), puntoSegmentoB.getX(), puntoSegmentoB.getY(),puntos->getX(), puntos->getY()))
			return true;
		else
			return false;
	}
	else
	{ // los 2 resultados
		if (segundaPendiente == *pendiente)
			return false;
		else
		{
			puntos->setX((*ordenada - segundaOrdenada) / (segundaPendiente - *pendiente));
			puntos->setY(*pendiente * puntos->getX() + *ordenada);
			if (verificaSiEstaEnRecta(puntoSegmentoA.getX(), puntoSegmentoA.getY(), puntoSegmentoB.getX(),puntoSegmentoB.getY(), puntos->getX(), puntos->getY()))
				return true;
			else
				return false;
		}
	}
}

//--------------------------------------------------------------------------------------------/

float colision::distanciaDeDosPuntos(punto puntoInicial, punto puntoFinal)
{
	float auxX, auxY, cuadradoX, cuadradoY;

	auxX = puntoInicial.getX() - puntoFinal.getX();
	auxY = puntoInicial.getY() - puntoFinal.getY();

	cuadradoX = auxX * auxX;
	cuadradoY = auxY * auxY;

	return sqrt(cuadradoX + cuadradoY);
}



//--------------------------------------------------------------------------------------------/
int colision::esgol(tejo* tejo){ // 0 - no es gol / 1 - gol p1 / 2 - gol p2 / > 2 ???


	//// lineas de gol

	int gol1y1,gol1y2;
	gol1y1=100;
	gol1y2=400;
					
		//verifico si hubo gol jugador1
	if( tejo->getCentro().getY()- tejo->getRadio() >gol1y1 && tejo->getCentro().getY()-tejo->getRadio() <gol1y2 && tejo->getCentro().getX() - tejo->getRadio()<10  )
	{	std::cout<<"gol1:"<<std::endl;
		return(1);				
	}

		//verifico si hubo gol jugador2
	if( tejo->getCentro().getY()-tejo->getRadio() >gol1y1 && tejo->getCentro().getY()-tejo->getRadio() <gol1y2 && tejo->getCentro().getX()+tejo->getRadio()>980  )
	{	std::cout<<"gol2:"<<std::endl;
		return(2);
	}

	return(0);

}
//--------------------------------------------------------------------------------------------/








bool colision::colisionSegmentoTejo(segmento* seg, tejo* tejo)
{

	double x, double y, double distancia;

	int xIni,int yIni, int xFin, int yFin;
	punto SegmentoIni, SegmentoFin;


		xIni = SegmentoIni.getX();
		yIni = SegmentoIni.getY();
		xFin = SegmentoFin.getX();
		yFin = SegmentoFin.getY();


		punto centroTejo;
		centroTejo = tejo->getCentro();

		float r0 = (float)tejo->getRadio();
		float cX = (float)centroTejo.getX();
		float cY = (float)centroTejo.getY();
		float xi = (float)xIni;
		float yi = (float)yIni;
		float xf = (float)xFin;
		float yf = (float)yFin;

		float A,B,C,m,o;
		float distMinX, distMinY;
		float menorDomX, mayorDomX, menorDomY, mayorDomY; // Domino del segmento
		float dist1;
		float dist2;
		float rY1=0, rY2=0, rX1=0, rX2=0, discr;
		int constantSegment;

		cY=(cY * (-1));
		yi=(yi * (-1));
		yf=(yf * (-1));

		if(xf-xi == 0)
		{
			A=1;
			B=-2*cY;
			C=(pow(cY,2)-pow(r0,2)+pow(xf-cX,2));
			constantSegment=CONSTANT_SEGMENT_V;
		}
		else if(yf-yi==0)
		{
			A=1;
			B=-2*cX;
			C=(pow(cX,2)-pow(r0,2)+pow(yf-cY,2));
			constantSegment=CONSTANT_SEGMENT_H;
		}
		else
		{
			m = (yf-yi)/(xf-xi);
			o = yi - xi*m;
			A = (1+pow(m,2));
			B = 2*(m*(o-cY) - cX);
			C = pow(cX,2) + pow(o-cY,2) - pow(r0,2);
			constantSegment=NON_CONSTANT_SEGMENT;
		}
		if(xi<xf){
			menorDomX = xi;
			mayorDomX = xf;
		}
		else{
			menorDomX = xf;
			mayorDomX = xi;
		}
		if(yi<yf){
			menorDomY = yi;
			mayorDomY = yf;
		}
		else{
			menorDomY = yf;
			mayorDomY = yi;
		}

		// Colision interna
		if(((pow(xi-cX, 2) + (pow(yi-cY,2))) < pow(r0, 2))
		  && ((pow(xf-cX, 2) + (pow(yf-cY,2))) < pow(r0, 2)))
		{
			//printf("El segmento se encuentra dentro de la circunferencia.\n");
			dist1=sqrt(pow(xi,2)+pow(yi,2));
			dist2=sqrt(pow(xf,2)+pow(yf,2));
			if(constantSegment==NON_CONSTANT_SEGMENT)
			{
				distMinX=(-m*o)/(1+pow(m,2)); //Derivada de la funcion distancia evaluada en 0
				distMinY = (distMinX-o)/m;
			}
			else if (constantSegment==CONSTANT_SEGMENT_H)
			{
				if(menorDomX<=0 && mayorDomX>=0)
				{
					distMinX=yi;
					distMinY=0;
				}
			}
			else if (constantSegment==CONSTANT_SEGMENT_V)
			{
				if(menorDomY<=0 && mayorDomY>=0)
				{
					distMinX=0;
					distMinY=xi;
				}
			}
			if(distMinX>=menorDomX && distMinX<=mayorDomX && constantSegment!=CONSTANT_SEGMENT_V)
			{
				distancia = sqrt(pow(distMinX,2)+pow(distMinY,2));
				x = distMinX;
				y = distMinY;
				return true;
			}
			else if(distMinY>=menorDomY && distMinY<=mayorDomY && constantSegment!=CONSTANT_SEGMENT_H)
			{
				distancia= sqrt(pow(distMinX,2)+pow(distMinY,2));
				x = distMinX;
				y = distMinY;
				return true;
			}
			else
			{
				if(dist1<dist2)
				{
					distancia = dist1;
					x = xi;
					y = yi;
					return true;
				}
				else
				{
					distancia = dist2;
					x = xf;
					y = yf;
					return true;
				}
			}
		}

		// Colision Externa (contornos)
		discr = (float)pow(B,2) - (float)(4*A*C);
		if((float)discr<0)
		{
			// No Colisionan
			distancia = -1;
			return false;
		}
		else
		{
			// Obtengo las raices
			if(constantSegment==NON_CONSTANT_SEGMENT)
			{
				rY1=((-B + sqrt(discr))/(2*A));
				rY2=((-B - sqrt(discr))/(2*A));
				rX1 = (rY1-o)/m;
				rX2 = (rY2-o)/m;
			}
			else if(constantSegment==CONSTANT_SEGMENT_V)
			{
				rY1=((-B + sqrt(discr))/(2*A));
				rY2=((-B - sqrt(discr))/(2*A));
				rX1=rX2=xi;
			}
			else if(constantSegment==CONSTANT_SEGMENT_H)
			{
				rX1=((-B + sqrt(discr))/(2*A));
				rX2=((-B - sqrt(discr))/(2*A));
				rY1=rY2=yi;
			}

			// Raiz Doble
			if(rY1==rY2 && rX1==rX2)
			{
				if(rX1>=menorDomX && rX1<=mayorDomX && rY1>=menorDomY && rY2 <=mayorDomY)
				{
					float dist=sqrt(pow(rX1,2)+pow(rY1,2));
					distancia = dist;
					x = rX1;
					y = rY1;
					return true;
				}
				else
				{
					// No Colisionan
					distancia = -1;
					return false;
				}
			}
			else
			// Dos raices
			{

				float dist1, dist2;
				// Chequeo dominio
				//if(!(rX1>=menorDomX && rX1<=mayorDomX)&&!(rX2>=menorDomX && rX2<=mayorDomX))
				if (!(rX1>=menorDomX && rX1<=mayorDomX && rY1>=menorDomY && rY1<=mayorDomY) &&
						!(rX2>=menorDomX && rX2<=mayorDomX && rY2>=menorDomY && rY2<=mayorDomY))
				{
					distancia = -1;
					return false;
				}
				// esto es util??
				if(rX1>=menorDomX && rX1<=mayorDomX && rY1>=menorDomY && rY1<=mayorDomY)
				{
					x = rX1;
					y =rY1;
				}
				if(rX2>=menorDomX && rX2<=mayorDomX && rY2>=menorDomY && rY2<=mayorDomY)
				{
					x = rX2;
					y = rY2;
				}
				// fin util?
				if(constantSegment==NON_CONSTANT_SEGMENT)
				{
					distMinX=(-m*o)/(1+pow(m,2)); //Derivada de la funcion distancia evaluada en 0
					distMinY = (distMinX-o)/m;
				}
				else if (constantSegment==CONSTANT_SEGMENT_H)
				{
					if(menorDomX<=0 && mayorDomX>=0)
					{
						distMinY=0;
						if((yi>=rX1&&yi<=rX2)||((yi>=rX2&&yi<=rX1)))
							distMinX=yi;
					}
				}
				else if (constantSegment==CONSTANT_SEGMENT_V)
				{
					if(menorDomY<=0 && mayorDomY>=0)
					{
						distMinX=0;
						if((xi>=rY1&&xi<=rY2)||((xi>=rY2&&xi<=rY1)))
							distMinY=xi;
					}
				}

				dist1=sqrt(pow(rX1,2)+pow(rY1,2));
				dist2=sqrt(pow(rX2,2)+pow(rY2,2));


				if(distMinX>=menorDomX && distMinX<=mayorDomX && constantSegment!=CONSTANT_SEGMENT_V)
				{
					distancia = sqrt(pow(distMinX,2)+pow(distMinY,2));
					return true;
				}
				else if(distMinY>=menorDomY && distMinY<=mayorDomY && constantSegment!=CONSTANT_SEGMENT_H)
				{
					distancia = sqrt(pow(distMinX,2)+pow(distMinY,2));
					return true;
				}
				else
				{
					if(dist1<dist2)
					{
						if(rX1>=menorDomX && rX1<=mayorDomX && rY1>=menorDomY && rY1<=mayorDomY)
						{
							distancia = dist1;
							x = rX1;
							y = rY1;
							return true;
						}
						else
						{
							distancia = dist2;
							x = rX2;
							y = rY2;
							return true;
						}
					}
					else
					{
						if(rX2>=menorDomX && rX2<=mayorDomX && rY2>=menorDomY && rY2<=mayorDomY)
						{
							distancia = dist2;
							x = rX2;
							y = rY2;
							return true;
						}
						else
						{
							distancia = dist1;
							x = rX1;
							y = rY1;
							return true;
						}
					}
				}
			}
		}
}






//-------------------------------------------------------------------------------------------/
bool colision::colisionTejoPad(tejo* tejo, punto puntoTejo,pad* pad)
{
	punto centroTejo, puntoA, puntoB, puntoC, puntoD, nuevoPunto, puntoUno, puntoDos, puntoTres, puntoCuatro;
	float radioTejo, angleTejo;
	bool resultado;


	radioTejo = tejo->getRadio();
	centroTejo = tejo->getCentro();
	angleTejo = tejo->getAngle();


	puntoCuatro = puntoTres = puntoDos = puntoUno = puntoTejo; //centro del tejo

	puntoUno.setY(puntoUno.getY() - radioTejo);
	puntoDos.setX(puntoDos.getX() + radioTejo);
	puntoTres.setY(puntoTres.getY() + radioTejo);
	puntoCuatro.setX(puntoCuatro.getX() - radioTejo);

	if (angleTejo >= 0 && angleTejo <= PI)
	{
		puntoTejo.setY(puntoTejo.getY() - radioTejo);
		float perpendicularidad = PI / 2.0f;
		if (angleTejo <= perpendicularidad)
		{
			puntoTejo.setX(puntoTejo.getX() + radioTejo);
		}

		else
		{
			puntoTejo.setX(puntoTejo.getX() - radioTejo);
		}

	}

	else
	{
		puntoTejo.setY(puntoTejo.getY() + radioTejo);
		float perpendicularidad = PI / 2.0f;
		if (angleTejo <= perpendicularidad)
				{
			puntoTejo.setX(puntoTejo.getX() + radioTejo);
		}

		else
		{
			puntoTejo.setX(puntoTejo.getX() - radioTejo);
		}

	}

	angleTejo = pasajeEntero(angleTejo / PI, 3);
	puntoA = pad->getPInicial();
	puntoB.setX(puntoA.getX() + pad->getAncho());
	puntoB.setY(puntoA.getY());
	puntoC.setX(puntoA.getX());
	puntoC.setY(puntoA.getY() + pad->getAlto());
	puntoD.setX(puntoB.getX());
	puntoD.setY(puntoC.getY());

	if(angleTejo >= 0 && angleTejo < 0.5)
	{

		resultado = colisionSegmentoHorizontal(puntoC,puntoD,centroTejo,puntoTejo,&nuevoPunto);

		if (resultado)
		{
			tejo->setAngle(2.0 * PI - tejo->getAngle());
			tejo->setPCentroNoClear(nuevoPunto);
			return true;
		}

		resultado = colisionSegmentoVertical(puntoA,puntoC,centroTejo,puntoTejo,&nuevoPunto);

		if (resultado)
		{
			tejo->setAngle(1.15*PI - tejo->getAngle());
			tejo->setPCentroNoClear(nuevoPunto);


			return true;
		}

		resultado = colisionSegmentoHorizontal(puntoC,puntoD,centroTejo,puntoUno,&nuevoPunto);

		if (resultado)
		{
			tejo->setAngle(2.0 * PI - tejo->getAngle());
			tejo->setPCentroNoClear(nuevoPunto);

			return true;
		}

		resultado = colisionSegmentoVertical(puntoA,puntoC,centroTejo,puntoUno,&nuevoPunto);

		if (resultado)

		{
			tejo->setAngle(1.15*PI - tejo->getAngle());
			tejo->setPCentroNoClear(nuevoPunto);

			return true;
		}

		resultado = colisionSegmentoHorizontal(puntoC,puntoD,centroTejo,puntoDos,&nuevoPunto);

		if (resultado)
		{
			tejo->setAngle(2.0 * PI - tejo->getAngle());
			tejo->setPCentroNoClear(nuevoPunto);
			return true;
		}

		resultado = colisionSegmentoVertical(puntoA,puntoC,centroTejo,puntoDos,&nuevoPunto);

		if (resultado)
		{
			tejo->setAngle(1.15*PI - tejo->getAngle());
			tejo->setPCentroNoClear(nuevoPunto);
			return true;
		}

		resultado = colisionSegmentoHorizontal(puntoC,puntoD,centroTejo,puntoTres,&nuevoPunto);

		if (resultado)
		{
			tejo->setAngle(2.0 * PI - tejo->getAngle());
			tejo->setPCentroNoClear(nuevoPunto);

			return true;
		}

		resultado = colisionSegmentoVertical(puntoA,puntoC,centroTejo,puntoTres,&nuevoPunto);

		if (resultado)
		{
			tejo->setAngle(1.15*PI - tejo->getAngle());
			tejo->setPCentroNoClear(nuevoPunto);
			return true;
		}

		resultado = colisionSegmentoHorizontal(puntoC,puntoD,centroTejo,puntoCuatro,&nuevoPunto);

		if (resultado)
		{
			tejo->setAngle(2.0 * PI - tejo->getAngle());
			tejo->setPCentroNoClear(nuevoPunto);
			return true;
		}

		resultado = colisionSegmentoVertical(puntoA,puntoC,centroTejo,puntoCuatro,&nuevoPunto);

		if (resultado)
		{
			tejo->setAngle(1.15*PI - tejo->getAngle());
			tejo->setPCentroNoClear(nuevoPunto);

			return true;
		}

	} else if(angleTejo >= 0.5 && angleTejo < 1.0) {

		resultado = colisionSegmentoHorizontal(puntoC,puntoD,centroTejo,puntoTejo,&nuevoPunto);

		if (resultado)
		{
			tejo->setAngle(2.0 * PI - tejo->getAngle());
			tejo->setPCentroNoClear(nuevoPunto);

			return true;
		}

		resultado = colisionSegmentoVertical(puntoB,puntoD,centroTejo,puntoTejo,&nuevoPunto);

		if (resultado)
		{
			tejo->setAngle(1.15*PI - tejo->getAngle());
			tejo->setPCentroNoClear(nuevoPunto);

			return true;
		}

		resultado = colisionSegmentoHorizontal(puntoC,puntoD,centroTejo,puntoUno,&nuevoPunto);

		if (resultado)
		{
			tejo->setAngle(2.0 * PI - tejo->getAngle());
			tejo->setPCentroNoClear(nuevoPunto);

			return true;
		}

		resultado = colisionSegmentoVertical(puntoB,puntoD,centroTejo,puntoUno,&nuevoPunto);

		if (resultado)
		{
			tejo->setAngle(1.15*PI - tejo->getAngle());
			tejo->setPCentroNoClear(nuevoPunto);

			return true;
		}

		resultado = colisionSegmentoHorizontal(puntoC,puntoD,centroTejo,puntoDos,&nuevoPunto);

		if (resultado)
		{
			tejo->setAngle(2.0 * PI - tejo->getAngle());
			tejo->setPCentroNoClear(nuevoPunto);

			return true;
		}

		resultado = colisionSegmentoVertical(puntoB,puntoD,centroTejo,puntoDos,&nuevoPunto);

		if (resultado)
		{
			tejo->setAngle(1.15*PI - tejo->getAngle());
			tejo->setPCentroNoClear(nuevoPunto);

			return true;
		}

		resultado = colisionSegmentoHorizontal(puntoC,puntoD,centroTejo,puntoTres,&nuevoPunto);

		if (resultado)
		{
			tejo->setAngle(2.0 * PI - tejo->getAngle());
			tejo->setPCentroNoClear(nuevoPunto);

			return true;
		}

		resultado = colisionSegmentoVertical(puntoB,puntoD,centroTejo,puntoTres,&nuevoPunto);

		if (resultado)
		{
			tejo->setAngle(1.15*PI - tejo->getAngle());
			tejo->setPCentroNoClear(nuevoPunto);

			return true;
		}

		resultado = colisionSegmentoHorizontal(puntoC,puntoD,centroTejo,puntoCuatro,&nuevoPunto);

		if (resultado)
		{
			tejo->setAngle(2.0 * PI - tejo->getAngle());
			tejo->setPCentroNoClear(nuevoPunto);

			return true;
		}

		resultado = colisionSegmentoVertical(puntoB,puntoD,centroTejo,puntoCuatro,&nuevoPunto);

		if (resultado)
		{
			tejo->setAngle(1.15*PI - tejo->getAngle());
			tejo->setPCentroNoClear(nuevoPunto);

			return true;
		}


	} else if(angleTejo >= 1.0 && angleTejo < 1.5) {

		resultado = colisionSegmentoHorizontal(puntoA,puntoB,centroTejo,puntoTejo,&nuevoPunto);

		if (resultado)
		{
			tejo->setAngle(2.0 * PI - tejo->getAngle());
			tejo->setPCentroNoClear(nuevoPunto);

			return true;
		}

		resultado = colisionSegmentoVertical(puntoB,puntoD,centroTejo,puntoTejo,&nuevoPunto);

		if (resultado)
{
			tejo->setAngle(1.15*PI - tejo->getAngle());
			tejo->setPCentroNoClear(nuevoPunto);

			return true;
		}

		resultado = colisionSegmentoHorizontal(puntoA,puntoB,centroTejo,puntoUno,&nuevoPunto);

		if (resultado)
		{
			tejo->setAngle(2.0 * PI - tejo->getAngle());
			tejo->setPCentroNoClear(nuevoPunto);

			return true;
		}

		resultado = colisionSegmentoVertical(puntoB,puntoD,centroTejo,puntoUno,&nuevoPunto);

		if (resultado)
		{
			tejo->setAngle(1.15*PI - tejo->getAngle());
			tejo->setPCentroNoClear(nuevoPunto);

			return true;
		}

		resultado = colisionSegmentoHorizontal(puntoA,puntoB,centroTejo,puntoDos,&nuevoPunto);

		if (resultado)
		{
			tejo->setAngle(2.0 * PI - tejo->getAngle());
			tejo->setPCentroNoClear(nuevoPunto);

			return true;
		}

		resultado = colisionSegmentoVertical(puntoB,puntoD,centroTejo,puntoDos,&nuevoPunto);

		if (resultado)
		{
			tejo->setAngle(1.15*PI - tejo->getAngle());
			tejo->setPCentroNoClear(nuevoPunto);

			return true;
		}

		resultado = colisionSegmentoHorizontal(puntoA,puntoB,centroTejo,puntoTres,&nuevoPunto);

		if (resultado)
		{
			tejo->setAngle(2.0 * PI - tejo->getAngle());
			tejo->setPCentroNoClear(nuevoPunto);

			return true;
		}

		resultado = colisionSegmentoVertical(puntoB,puntoD,centroTejo,puntoTres,&nuevoPunto);

		if (resultado)
		{
			tejo->setAngle(1.15*PI - tejo->getAngle());
			tejo->setPCentroNoClear(nuevoPunto);

			return true;
		}

		resultado = colisionSegmentoHorizontal(puntoA,puntoB,centroTejo,puntoCuatro,&nuevoPunto);

		if (resultado)
		{
			tejo->setAngle(2.0 * PI - tejo->getAngle());
			tejo->setPCentroNoClear(nuevoPunto);

			return true;
		}

		resultado = colisionSegmentoVertical(puntoB,puntoD,centroTejo,puntoCuatro,&nuevoPunto);

		if (resultado)
		{
			tejo->setAngle(1.15*PI - tejo->getAngle());
			tejo->setPCentroNoClear(nuevoPunto);

			return true;
		}


	}

	else if (angleTejo >= 1.5)
	{

		resultado = colisionSegmentoHorizontal(puntoA,puntoB,centroTejo,puntoTejo,&nuevoPunto);

		if (resultado)
		{
			tejo->setAngle(2.0 * PI - tejo->getAngle());
			tejo->setPCentroNoClear(nuevoPunto);

			return true;
		}

		resultado = colisionSegmentoVertical(puntoA,puntoC,centroTejo,puntoTejo,&nuevoPunto);

		if (resultado)
		{
			tejo->setAngle(1.15*PI - tejo->getAngle());
			tejo->setPCentroNoClear(nuevoPunto);

			return true;
		}

		resultado = colisionSegmentoHorizontal(puntoA,puntoB,centroTejo,puntoUno,&nuevoPunto);

		if (resultado)
		{
			tejo->setAngle(2.0 * PI - tejo->getAngle());
				tejo->setPCentroNoClear(nuevoPunto);

			return true;
		}

		resultado = colisionSegmentoVertical(puntoA,puntoC,centroTejo,puntoUno,&nuevoPunto);

		if (resultado)
		{
			tejo->setAngle(1.15*PI - tejo->getAngle());
			tejo->setPCentroNoClear(nuevoPunto);

			return true;
		}

		resultado = colisionSegmentoHorizontal(puntoA,puntoB,centroTejo,puntoDos,&nuevoPunto);

		if (resultado)
		{
			tejo->setAngle(2.0 * PI - tejo->getAngle());
			tejo->setPCentroNoClear(nuevoPunto);

			return true;
		}

		resultado = colisionSegmentoVertical(puntoA,puntoC,centroTejo,puntoDos,&nuevoPunto);

		if (resultado)
		{
			tejo->setAngle(1.15*PI - tejo->getAngle());
		tejo->setPCentroNoClear(nuevoPunto);

			return true;
		}

		resultado = colisionSegmentoHorizontal(puntoA,puntoB,centroTejo,puntoTres,&nuevoPunto);

		if (resultado)
		{
			tejo->setAngle(2.0 * PI - tejo->getAngle());
			tejo->setPCentroNoClear(nuevoPunto);

			return true;
		}

		resultado = colisionSegmentoVertical(puntoA,puntoC,centroTejo,puntoTres,&nuevoPunto);

		if (resultado)
		{
			tejo->setAngle(1.15*PI - tejo->getAngle());
			tejo->setPCentroNoClear(nuevoPunto);

			return true;
		}

		resultado = colisionSegmentoHorizontal(puntoA,puntoB,centroTejo,puntoCuatro,&nuevoPunto);

		if (resultado)
		{
			tejo->setAngle(2.0 * PI - tejo->getAngle());
			tejo->setPCentroNoClear(nuevoPunto);

			return true;
		}

		resultado = colisionSegmentoVertical(puntoA,puntoC,centroTejo,puntoCuatro,&nuevoPunto);

		if (resultado)
		{
			tejo->setAngle(1.15*PI - tejo->getAngle());
			tejo->setPCentroNoClear(nuevoPunto);
			return true;
		}

	}

	return false;
}


//--------------------------------------------------------------------------------------------/


bool colision::colisionTejoRectangulo(tejo* tejo, punto puntoTejo,rectangulo* pad)
{
	punto centroTejo, puntoA, puntoB, puntoC, puntoD, nuevoPunto, puntoUno, puntoDos, puntoTres, puntoCuatro;
	float radioTejo, angleTejo;
	bool resultado;


	radioTejo = tejo->getRadio();
	centroTejo = tejo->getCentro();
	angleTejo = tejo->getAngle();


	puntoCuatro = puntoTres = puntoDos = puntoUno = puntoTejo; //centro del tejo

	puntoUno.setY(puntoUno.getY() - radioTejo);
	puntoDos.setX(puntoDos.getX() + radioTejo);
	puntoTres.setY(puntoTres.getY() + radioTejo);
	puntoCuatro.setX(puntoCuatro.getX() - radioTejo);

	if (angleTejo >= 0 && angleTejo <= PI)
	{
		puntoTejo.setY(puntoTejo.getY() - radioTejo);
		float perpendicularidad = PI / 2.0f;
		if (angleTejo <= perpendicularidad)
		{
			puntoTejo.setX(puntoTejo.getX() + radioTejo);
		}

		else
		{
			puntoTejo.setX(puntoTejo.getX() - radioTejo);
		}

	}

	else
	{
		puntoTejo.setY(puntoTejo.getY() + radioTejo);
		float perpendicularidad = PI / 2.0f;
		if (angleTejo <= perpendicularidad)
				{
			puntoTejo.setX(puntoTejo.getX() + radioTejo);
		}

		else
		{
			puntoTejo.setX(puntoTejo.getX() - radioTejo);
		}

	}

	angleTejo = pasajeEntero(angleTejo / PI, 3);
	puntoA = pad->getPuntoInicial();
	puntoB.setX(puntoA.getX() + pad->getAncho());
	puntoB.setY(puntoA.getY());
	puntoC.setX(puntoA.getX());
	puntoC.setY(puntoA.getY() + pad->getAlto());
	puntoD.setX(puntoB.getX());
	puntoD.setY(puntoC.getY());

	if(angleTejo >= 0 && angleTejo < 0.5)
	{

		resultado = colisionSegmentoHorizontal(puntoC,puntoD,centroTejo,puntoTejo,&nuevoPunto);

		if (resultado)
		{
			tejo->setAngle(1.15*PI - tejo->getAngle());
			tejo->setPCentroNoClear(nuevoPunto);
			return true;
		}

		resultado = colisionSegmentoVertical(puntoA,puntoC,centroTejo,puntoTejo,&nuevoPunto);

		if (resultado)
		{
			tejo->setAngle(1.15*PI - tejo->getAngle());
			tejo->setPCentroNoClear(nuevoPunto);


			return true;
		}

		resultado = colisionSegmentoHorizontal(puntoC,puntoD,centroTejo,puntoUno,&nuevoPunto);

		if (resultado)
		{
					tejo->setAngle(1.15*PI - tejo->getAngle());
			tejo->setPCentroNoClear(nuevoPunto);

			return true;
		}

		resultado = colisionSegmentoVertical(puntoA,puntoC,centroTejo,puntoUno,&nuevoPunto);

		if (resultado)

		{
			tejo->setAngle(1.15*PI - tejo->getAngle());
			tejo->setPCentroNoClear(nuevoPunto);

			return true;
		}

		resultado = colisionSegmentoHorizontal(puntoC,puntoD,centroTejo,puntoDos,&nuevoPunto);

		if (resultado)
		{
						tejo->setAngle(1.15*PI - tejo->getAngle());
			tejo->setPCentroNoClear(nuevoPunto);
			return true;
		}

		resultado = colisionSegmentoVertical(puntoA,puntoC,centroTejo,puntoDos,&nuevoPunto);

		if (resultado)
		{
			tejo->setAngle(1.15*PI - tejo->getAngle());
			tejo->setPCentroNoClear(nuevoPunto);
			return true;
		}

		resultado = colisionSegmentoHorizontal(puntoC,puntoD,centroTejo,puntoTres,&nuevoPunto);

		if (resultado)
		{
					tejo->setAngle(1.15*PI - tejo->getAngle());
			tejo->setPCentroNoClear(nuevoPunto);

			return true;
		}

		resultado = colisionSegmentoVertical(puntoA,puntoC,centroTejo,puntoTres,&nuevoPunto);

		if (resultado)
		{
			tejo->setAngle(1.15*PI - tejo->getAngle());
			tejo->setPCentroNoClear(nuevoPunto);
			return true;
		}

		resultado = colisionSegmentoHorizontal(puntoC,puntoD,centroTejo,puntoCuatro,&nuevoPunto);

		if (resultado)
		{
					tejo->setAngle(1.15*PI - tejo->getAngle());
			tejo->setPCentroNoClear(nuevoPunto);
			return true;
		}

		resultado = colisionSegmentoVertical(puntoA,puntoC,centroTejo,puntoCuatro,&nuevoPunto);

		if (resultado)
		{
			tejo->setAngle(1.15*PI - tejo->getAngle());
			tejo->setPCentroNoClear(nuevoPunto);

			return true;
		}

	} else if(angleTejo >= 0.5 && angleTejo < 1.0) {

		resultado = colisionSegmentoHorizontal(puntoC,puntoD,centroTejo,puntoTejo,&nuevoPunto);

		if (resultado)
		{
						tejo->setAngle(1.15*PI - tejo->getAngle());
			tejo->setPCentroNoClear(nuevoPunto);

			return true;
		}

		resultado = colisionSegmentoVertical(puntoB,puntoD,centroTejo,puntoTejo,&nuevoPunto);

		if (resultado)
		{
			tejo->setAngle(1.15*PI - tejo->getAngle());
			tejo->setPCentroNoClear(nuevoPunto);

			return true;
		}

		resultado = colisionSegmentoHorizontal(puntoC,puntoD,centroTejo,puntoUno,&nuevoPunto);

		if (resultado)
		{
						tejo->setAngle(1.15*PI - tejo->getAngle());
			tejo->setPCentroNoClear(nuevoPunto);

			return true;
		}

		resultado = colisionSegmentoVertical(puntoB,puntoD,centroTejo,puntoUno,&nuevoPunto);

		if (resultado)
		{
			tejo->setAngle(1.15*PI - tejo->getAngle());
			tejo->setPCentroNoClear(nuevoPunto);

			return true;
		}

		resultado = colisionSegmentoHorizontal(puntoC,puntoD,centroTejo,puntoDos,&nuevoPunto);

		if (resultado)
		{
						tejo->setAngle(1.15*PI - tejo->getAngle());
			tejo->setPCentroNoClear(nuevoPunto);

			return true;
		}

		resultado = colisionSegmentoVertical(puntoB,puntoD,centroTejo,puntoDos,&nuevoPunto);

		if (resultado)
		{
			tejo->setAngle(1.15*PI - tejo->getAngle());
			tejo->setPCentroNoClear(nuevoPunto);

			return true;
		}

		resultado = colisionSegmentoHorizontal(puntoC,puntoD,centroTejo,puntoTres,&nuevoPunto);

		if (resultado)
		{
						tejo->setAngle(1.15*PI - tejo->getAngle());
			tejo->setPCentroNoClear(nuevoPunto);

			return true;
		}

		resultado = colisionSegmentoVertical(puntoB,puntoD,centroTejo,puntoTres,&nuevoPunto);

		if (resultado)
		{
			tejo->setAngle(1.15*PI - tejo->getAngle());
			tejo->setPCentroNoClear(nuevoPunto);

			return true;
		}

		resultado = colisionSegmentoHorizontal(puntoC,puntoD,centroTejo,puntoCuatro,&nuevoPunto);

		if (resultado)
		{
			tejo->setAngle(1.15*PI - tejo->getAngle());
			tejo->setPCentroNoClear(nuevoPunto);

			return true;
		}

		resultado = colisionSegmentoVertical(puntoB,puntoD,centroTejo,puntoCuatro,&nuevoPunto);

		if (resultado)
		{
			tejo->setAngle(1.15*PI - tejo->getAngle());
			tejo->setPCentroNoClear(nuevoPunto);

			return true;
		}


	} else if(angleTejo >= 1.0 && angleTejo < 1.5) {

		resultado = colisionSegmentoHorizontal(puntoA,puntoB,centroTejo,puntoTejo,&nuevoPunto);

		if (resultado)
		{
					tejo->setAngle(1.15*PI - tejo->getAngle());
			tejo->setPCentroNoClear(nuevoPunto);

			return true;
		}

		resultado = colisionSegmentoVertical(puntoB,puntoD,centroTejo,puntoTejo,&nuevoPunto);

		if (resultado)
{
			tejo->setAngle(1.15*PI - tejo->getAngle());
			tejo->setPCentroNoClear(nuevoPunto);

			return true;
		}

		resultado = colisionSegmentoHorizontal(puntoA,puntoB,centroTejo,puntoUno,&nuevoPunto);

		if (resultado)
		{
					tejo->setAngle(1.15*PI - tejo->getAngle());
			tejo->setPCentroNoClear(nuevoPunto);

			return true;
		}

		resultado = colisionSegmentoVertical(puntoB,puntoD,centroTejo,puntoUno,&nuevoPunto);

		if (resultado)
		{
			tejo->setAngle(1.15*PI - tejo->getAngle());
			tejo->setPCentroNoClear(nuevoPunto);

			return true;
		}

		resultado = colisionSegmentoHorizontal(puntoA,puntoB,centroTejo,puntoDos,&nuevoPunto);

		if (resultado)
		{
					tejo->setAngle(1.15*PI - tejo->getAngle());
			tejo->setPCentroNoClear(nuevoPunto);

			return true;
		}

		resultado = colisionSegmentoVertical(puntoB,puntoD,centroTejo,puntoDos,&nuevoPunto);

		if (resultado)
		{
			tejo->setAngle(1.15*PI - tejo->getAngle());
			tejo->setPCentroNoClear(nuevoPunto);

			return true;
		}

		resultado = colisionSegmentoHorizontal(puntoA,puntoB,centroTejo,puntoTres,&nuevoPunto);

		if (resultado)
		{
					tejo->setAngle(1.15*PI - tejo->getAngle());
			tejo->setPCentroNoClear(nuevoPunto);

			return true;
		}

		resultado = colisionSegmentoVertical(puntoB,puntoD,centroTejo,puntoTres,&nuevoPunto);

		if (resultado)
		{
			tejo->setAngle(1.15*PI - tejo->getAngle());
			tejo->setPCentroNoClear(nuevoPunto);

			return true;
		}

		resultado = colisionSegmentoHorizontal(puntoA,puntoB,centroTejo,puntoCuatro,&nuevoPunto);

		if (resultado)
		{
					tejo->setAngle(1.15*PI - tejo->getAngle());
			tejo->setPCentroNoClear(nuevoPunto);

			return true;
		}

		resultado = colisionSegmentoVertical(puntoB,puntoD,centroTejo,puntoCuatro,&nuevoPunto);

		if (resultado)
		{
			tejo->setAngle(1.15*PI - tejo->getAngle());
			tejo->setPCentroNoClear(nuevoPunto);

			return true;
		}


	}

	else if (angleTejo >= 1.5)
	{

		resultado = colisionSegmentoHorizontal(puntoA,puntoB,centroTejo,puntoTejo,&nuevoPunto);

		if (resultado)
		{
					tejo->setAngle(1.15*PI - tejo->getAngle());
			tejo->setPCentroNoClear(nuevoPunto);

			return true;
		}

		resultado = colisionSegmentoVertical(puntoA,puntoC,centroTejo,puntoTejo,&nuevoPunto);

		if (resultado)
		{
			tejo->setAngle(1.15*PI - tejo->getAngle());
			tejo->setPCentroNoClear(nuevoPunto);

			return true;
		}

		resultado = colisionSegmentoHorizontal(puntoA,puntoB,centroTejo,puntoUno,&nuevoPunto);

		if (resultado)
		{
						tejo->setAngle(1.15*PI - tejo->getAngle());
				tejo->setPCentroNoClear(nuevoPunto);

			return true;
		}

		resultado = colisionSegmentoVertical(puntoA,puntoC,centroTejo,puntoUno,&nuevoPunto);

		if (resultado)
		{
			tejo->setAngle(1.15*PI - tejo->getAngle());
			tejo->setPCentroNoClear(nuevoPunto);

			return true;
		}

		resultado = colisionSegmentoHorizontal(puntoA,puntoB,centroTejo,puntoDos,&nuevoPunto);

		if (resultado)
		{
				tejo->setAngle(1.15*PI - tejo->getAngle());
			tejo->setPCentroNoClear(nuevoPunto);

			return true;
		}

		resultado = colisionSegmentoVertical(puntoA,puntoC,centroTejo,puntoDos,&nuevoPunto);

		if (resultado)
		{
			tejo->setAngle(1.15*PI - tejo->getAngle());
		tejo->setPCentroNoClear(nuevoPunto);

			return true;
		}

		resultado = colisionSegmentoHorizontal(puntoA,puntoB,centroTejo,puntoTres,&nuevoPunto);

		if (resultado)
		{
						tejo->setAngle(1.15*PI - tejo->getAngle());
			tejo->setPCentroNoClear(nuevoPunto);

			return true;
		}

		resultado = colisionSegmentoVertical(puntoA,puntoC,centroTejo,puntoTres,&nuevoPunto);

		if (resultado)
		{
			tejo->setAngle(1.15*PI - tejo->getAngle());
			tejo->setPCentroNoClear(nuevoPunto);

			return true;
		}

		resultado = colisionSegmentoHorizontal(puntoA,puntoB,centroTejo,puntoCuatro,&nuevoPunto);

		if (resultado)
		{
				tejo->setAngle(1.15*PI - tejo->getAngle());
			tejo->setPCentroNoClear(nuevoPunto);

			return true;
		}

		resultado = colisionSegmentoVertical(puntoA,puntoC,centroTejo,puntoCuatro,&nuevoPunto);

		if (resultado)
		{
			tejo->setAngle(1.15*PI - tejo->getAngle());
			tejo->setPCentroNoClear(nuevoPunto);
			return true;
		}

	}

	return false;
}


//--------------------------------------------------------------------------------------------/

bool colision::colisionTrianguloTejo(triangulo* triangulo,tejo* tejo)
{
	float pendiente, ordenada;
	punto puntos, puntoUno, puntoDos, puntoTres, centroTejo;
	bool resultado;

	puntoUno = triangulo->getPuntoA();
	puntoDos = triangulo->getPuntoB();
	puntoTres = triangulo->getPuntoC();
	centroTejo = tejo->getCentro();

	if (distanciaDeDosPuntos(puntoUno, centroTejo) <= tejo->getRadio()) {
		obtenerPendienteORdenada(puntoDos.getX(), puntoDos.getY(), puntoTres.getX(), puntoTres.getY(), &pendiente, &ordenada);
		tejo->setAngle(2.0 * PI - tejo->getAngle() - 2.0 * atan(pendiente));
		//tejo->desplazar();
		//tejo->desplazar();
		return true;
	}

	if (distanciaDeDosPuntos(puntoDos, centroTejo) <= tejo->getRadio()) {
		obtenerPendienteORdenada(puntoTres.getX(), puntoTres.getY(), puntoUno.getX(), puntoUno.getY(), &pendiente, &ordenada);
		tejo->setAngle(2.0 * PI - tejo->getAngle() - 2.0 * atan(pendiente));
		//tejo->desplazar();
		//tejo->desplazar();
		return true;
	}

	if (distanciaDeDosPuntos(puntoTres, centroTejo) <= tejo->getRadio()) {
		obtenerPendienteORdenada(puntoUno.getX(), puntoUno.getY(), puntoDos.getX(), puntoDos.getY(), &pendiente, &ordenada);
		tejo->setAngle(2.0 * PI - tejo->getAngle() - 2.0 * atan(pendiente));
		//tejo->desplazar();
		//tejo->desplazar();
		return true;
	}





	resultado = colisionSegmentoRecta(centroTejo, puntoUno, puntoDos, puntoTres, &pendiente, &ordenada, &puntos);

	if (resultado) {
		if (distanciaDeDosPuntos(centroTejo, puntos) <= tejo->getRadio()) {
			tejo->setAngle(2.0 * PI - tejo->getAngle() - 2.0 * atan(pendiente));
			//tejo->desplazar();
			//tejo->desplazar();
			return true;
		}
	}

	resultado = colisionSegmentoRecta(centroTejo, puntoTres, puntoUno, puntoDos, &pendiente, &ordenada, &puntos);

	if (resultado) {
		if (distanciaDeDosPuntos(centroTejo, puntos) <= tejo->getRadio()) {
			tejo->setAngle(2.0 * PI - tejo->getAngle() - 2.0 * atan(pendiente));
			//tejo->desplazar();
			//tejo->desplazar();
			return true;
		}
	}

	resultado = colisionSegmentoRecta(centroTejo, puntoDos, puntoTres, puntoUno, &pendiente, &ordenada, &puntos);

	if (resultado) {
		if (distanciaDeDosPuntos(centroTejo, puntos) <= tejo->getRadio()) {
			tejo->setAngle(2.0 * PI - tejo->getAngle() - 2.0 * atan(pendiente));
			//tejo->desplazar();
			////tejo->desplazar();
			return true;
		}
	}

	return false;

}


//--------------------------------------------------------------------------------------------/


bool colision::interseccionSegmentoCirculo(punto* p1, circulo* circulo, punto* pInt, float* M, float* C) {
       bool state;
       double m, c, solX, solY, x1, y1, x2, y2, r, a1, b1, c1, discr;

       x1 = p1->getX();
       y1 = p1->getY();
       x2 = circulo->getCentro().getX();
       y2 = circulo->getCentro().getY();
       r = circulo->getRadio();

       state = obtenerPendienteORdenada(x1, y1, x2, y2, M, C);

       if (!state) {
               solX = x2;
               solY = y2 + r;
               if (verificaSiEstaEnRecta(x1, y1, x2, y2, solX, solY)) {
                       pInt->setX(solX);
                       pInt->setY(solY);
               } else {
                       solY = y2 - r;
                       pInt->setX(solX);
                       pInt->setY(solY);
               }

       } else {
               m = *M;
               c = *C;

               a1 = 1 + (m * m);
               b1 = (2 * m * c) - (2 * x2) - (2 * m * y2);
               c1 = (x2 * x2) + (c * c) + (y2 * y2) - (2 * y2 * c) - (r * r);
               discr = (b1 * b1) - (4 * a1 * c1);

               solX = (-b1 + sqrt(discr)) / (2 * a1);
               solY = m * solX + c;

               if (verificaSiEstaEnRecta(x1, y1, x2, y2, solX, solY)) 
			   
			   {
                       pInt->setX(solX);
                       pInt->setY(solY);
               } else {
                       solX = (-b1 - sqrt(discr)) / (2 * a1);
                       solY = m * solX + c;
                       pInt->setX(solX);
                       pInt->setY(solY);
               }

       }

       return state;

}




double distancia(punto inicio,punto final)
{
double x,y,a,b;

x=inicio.getX()-final.getX();
y=inicio.getY()-final.getY();

a=x*x;
b=y*y;
return sqrt(a+b);

}

//-------------------------------------------------------------------------------------------//

bool colision::colisionCirculoTejo(circulo* circulo, tejo* tejo) 
{
       double distanciaObtenida, nuevoAngle;
	   float pendiente,c;
       punto puntos;


       distanciaObtenida = distancia(circulo->getCentro(), tejo->getCentro());

       if (distanciaObtenida < circulo->getRadio() + tejo->getRadio()) 
	   {
               if (interseccionSegmentoCirculo(&tejo->getCentro(), circulo, &puntos,
                               &pendiente, &c)) {
                       if (pendiente != 0) {
                               nuevoAngle = 2.0 * PI - tejo->getAngle() - 2.0 * atan(-1.0 / pendiente);
                               tejo->setAngle(nuevoAngle);
                               tejo->desplazar_server();
                               return true;

                       } else {
                               nuevoAngle = 2.0 * PI - tejo->getAngle();
                               tejo->setAngle(nuevoAngle);
                               tejo->desplazar_server();
                               return true;
                       }

               } else {
                       nuevoAngle = PI - tejo->getAngle();
                       tejo->setAngle(nuevoAngle);
                        tejo->desplazar_server();;
                       return true;

               }
       }
       return false;

}


//---------------------------------------------------------------------------------------------/

void colision::rectangulo_1(){

punto vert1,vert2,vert3;

int MaxX;
int MinX;
int MMY;
int cant_rect;
float deltaX;
float mitad_triangulo;
int t_tipo; // 1 - Para arriba 2 - para abajo


float total_recorrido;


float X0_Out;
float Xf_Out;
float Y0_Out;
float y_Out;


cant_rect = 32;
total_recorrido = 0;


vert1.setX(450);
vert1.setY(170);

vert2.setX(500);
vert2.setY(85);

vert3.setX(550);
vert3.setY(170);

//-----MAX X---------//
MaxX = vert1.getX();
if (vert2.getX() > MaxX) {MaxX = vert2.getX();}
if (vert3.getX() > MaxX) {MaxX = vert3.getX();}
//-----MAX X---------//

//-----MIN X---------//
MinX = vert1.getX();
if (vert2.getX() < MinX) {MinX = vert2.getX();}
if (vert3.getX() < MinX) {MinX = vert3.getX();}
//-----MIN Y---------//

//-----MAX/ MIN Y-----//

MMY = vert1.getY();
t_tipo = 2; 
if(MMY < vert2.getY()){t_tipo=1;}
Y0_Out = vert2.getY();

if(vert1.getY()==vert2.getY()){
	MMY = vert3.getY();
	Y0_Out = vert1.getY();
	if(MMY < vert2.getY()){t_tipo=1;}
}
if(vert1.getY()==vert3.getY()){
	MMY = vert2.getY();
	Y0_Out = vert1.getY();
	if(MMY < vert1.getY()){t_tipo=1;}
}


//-------------------//


//------Calc Delta X-------//
deltaX = (MaxX - MinX) / cant_rect;
mitad_triangulo = (MaxX - MinX) / 2;
//------Calc Delta X-------//


//----------Iterar---------------//

while (total_recorrido < MaxX - MinX){

X0_Out = total_recorrido;
Xf_Out = total_recorrido + deltaX;

if (Xf_Out < (mitad_triangulo)){ // Primera mitad del triangulo
	y_Out = (MMY/mitad_triangulo) * total_recorrido;
}
else // Segunda Mitad del triangulo
{
	y_Out = (MMY/mitad_triangulo) * (mitad_triangulo-(total_recorrido-mitad_triangulo));

}

total_recorrido = total_recorrido + deltaX;


X0_Out = X0_Out + MinX;
Xf_Out = Xf_Out + MinX;
if (t_tipo==1) {y_Out = - y_Out ;}
if (t_tipo==2) {y_Out = MMY + y_Out;}

std::cout<<"x0:"<<X0_Out<<" xf:"<<Xf_Out<<"y0:"<< Y0_Out << " y:"<<y_Out<<std::endl;

}

//----------Iterar---------------//
}





//--------------------------------------------------------------------------------------------/
/*bool colision::colisionCirculoTejo(circulo* circulo,tejo* tejo)
{
	punto centro;
	
	int r0;
	float x0;
	float y0;

	
	int r1;
	float x1;
	float y1;

	r0 = circulo->getRadio()*1.234;
	centro = circulo->getCentro();
	x0 = centro.getX();
	y0 = centro.getY();

	r1 = tejo->getRadio();
	centro = tejo->getCentro();
	x1 = centro.getX();
	y1 = centro.getY();


	float pendiente;
	float ordenada;
	punto punto;


	float dist, dist1, dist2, D, G, E, F, H, I, M, N, a, b, c, rY1, rY2, discr, rX1, rX2;
	y0=y0*-1;
	y1=y1*-1;
	if(r0 <= 0 || r1 <= 0)
	{
		//printf("ERROR: Los radios de las circunferencias deben ser positivos.\n");
		return false;
	}
	// Chequeo igualdad
	if(r0==r1 && x0==x1 && y0==y1)
	{
		return true;
	}

	else
	{
		// Chequeo colision interna (figura solida)
		if(r0>r1)
		{
			dist= sqrt(pow(x0-x1,2)+pow(y0-y1,2));
			if((dist+r1)<r0)
			{
				// Calculo la distancia minima (del circulo 2)
				dist = sqrt(pow(x1,2)+pow(y1,2)) - r1;
				return true;
			}
		}
		else if(r1>r0)
		{
			dist= sqrt(pow(x0-x1,2)+pow(y0-y1,2));
			if((dist+r0)<r1)
			{
				// Calculo la distancia minima (del circulo 1)
				dist = sqrt(pow(x0,2)+pow(y0,2)) - r0;
				return true;
			}
		}


		// Chequeo colision externa (contorno)
		D=-2.0f*x0, E=-2.0f*y0, F=(pow(x0,2) + pow(y0,2) - pow(r0,2));
		G=-2.0f*x1, H=-2.0f*y1, I=(pow(x1,2) + pow(y1,2) - pow(r1,2));
		M=((H-E)/(D-G));
		N=((I-F)/(D-G));

		// Parametros de la funcion cuadratica
		a = (pow(M,2)) + 1;
		b = ((2*M*N)+ D*M + E);
		c = (pow(N,2) + D*N + F);
		rY1=0, rY2=0;
		discr = pow(b,2) - (4*a*c);
		if(discr<0)
		{
			return false;
		}
		else
		{
			rY1=((-b + sqrt(discr))/(2*a));
			rY2=((-b - sqrt(discr))/(2*a));

			rX1 = (sqrt(pow(r0,2)-pow((rY1-y0),2)) + x0);
			rX2 = (sqrt(pow(r1,2)-pow((rY2-y1),2)) + x1);
			dist1=sqrt(pow(rX1,2)+pow(rY1, 2));
			dist2=sqrt(pow(rX2,2)+pow(rY2, 2));

			if(dist2<dist1)
			{
				
				
				//tejo->setAngle(2.0 * PI - tejo->getAngle());
				if (interseccionSegmentoCirculo(&tejo->getCentro(),circulo,&punto,&pendiente,&ordenada))
				{
					if(pendiente!=0){tejo->setAngle(2.0 * PI - tejo->getAngle() - 2.0 * atan(-1.0/pendiente));}
					else{tejo->setAngle(2.0 * PI - tejo->getAngle());}
					//tejo->desplazar();
				return true;	
				} 				
							
			}
			else
			{
				tejo->setAngle(PI - tejo->getAngle());
				//tejo->desplazar();
				return true;
			}
		}
	}
}
*/




///////////////////*




//--------------------------------------------------------------------------------------------/

bool colision::colisionTrianguloTejo2(triangulo* triangulo,tejo* tejo)
{
	float pendiente, ordenada;
	pendiente=0;
	punto puntos, puntoUno, puntoDos, puntoTres, centroTejo;
	bool resultado;

	puntoUno = triangulo->getPuntoA();
	puntoUno.setX(puntoUno.getX()+0.1);     
	puntoUno.setY(puntoUno.getY()+0.2); 
	
	puntoDos = triangulo->getPuntoB();
	puntoDos.setX(puntoDos.getX()-0.3);
	puntoDos.setY(puntoDos.getY()+0.4);

	puntoTres = triangulo->getPuntoC();
	puntoTres.setX(puntoTres.getX()+0.5); 
	puntoTres.setY(puntoTres.getY()-0.6);  


	centroTejo = tejo->getCentro();


	if (distanciaDeDosPuntos(puntoUno, centroTejo) <= tejo->getRadio()) {
		obtenerPendienteORdenada(puntoDos.getX(), puntoDos.getY(), puntoTres.getX(), puntoTres.getY(), &pendiente, &ordenada);
		tejo->setAngle(1.05 * PI + tejo->getAngle()+  atan(pendiente)/1000);//	tejo->setAngle(1.25* PI);//	tejo->setAngle(2.0* PI - tejo->getAngle() - 2.0 * atan(pendiente)/0.5);

	
		tejo->desplazar_server();
	//	tejo->desplazar_server();
		return true;
	}

	if (distanciaDeDosPuntos(puntoDos, centroTejo) <= tejo->getRadio()) {
		obtenerPendienteORdenada(puntoTres.getX(), puntoTres.getY(), puntoUno.getX(), puntoUno.getY(), &pendiente, &ordenada);
		tejo->setAngle(1.05 * PI + tejo->getAngle()+  atan(pendiente)/1000);//tejo->setAngle(1.05 * PI);//			tejo->setAngle(2.0 * PI - tejo->getAngle() - 2.0 * atan(pendiente));//	tejo->setAngle(1.25 * PI);//tejo->setAngle(2.0* PI - tejo->getAngle() - 2.0 * atan(pendiente)/0.5);
		tejo->desplazar_server();
		//tejo->desplazar_server();
	return true;
	}

	if (distanciaDeDosPuntos(puntoTres, centroTejo) <= tejo->getRadio()) {
		obtenerPendienteORdenada(puntoUno.getX(), puntoUno.getY(), puntoDos.getX(), puntoDos.getY(), &pendiente, &ordenada);
		tejo->setAngle(1.05 * PI + tejo->getAngle()+  atan(pendiente)/1000);////tejo->setAngle(1.05 * PI);//	tejo->setAngle(2.0 * PI - tejo->getAngle() - 2.0 * atan(pendiente));//tejo->setAngle(1.25 * PI);// - tejo->getAngle() - 2.0 * atan(pendiente)/0.5);
		tejo->desplazar_server();
		//tejo->desplazar_server();
		return true;
	}





	resultado = colisionSegmentoRecta(centroTejo, puntoUno, puntoDos, puntoTres, &pendiente, &ordenada, &puntos);

	if (resultado) {
		if (distanciaDeDosPuntos(centroTejo, puntos) <= tejo->getRadio()) {
		tejo->setAngle(1.05 * PI + tejo->getAngle()+  atan(pendiente)/1000);////	tejo->setAngle(1.05 * PI);//	tejo->setAngle(2.0* PI - tejo->getAngle() - 2.0 * atan(pendiente));
	tejo->desplazar_server();
	//tejo->desplazar_server();
			return true;
		}
	}

	resultado = colisionSegmentoRecta(centroTejo, puntoTres, puntoUno, puntoDos, &pendiente, &ordenada, &puntos);

	if (resultado) {
		if (distanciaDeDosPuntos(centroTejo, puntos) <= tejo->getRadio()) {
		tejo->setAngle(1.05 * PI + tejo->getAngle()+  atan(pendiente)/1000);//	tejo->setAngle(2.0 * PI - tejo->getAngle() - 2.0 * atan(pendiente));
		tejo->desplazar_server();
		//tejo->desplazar_server();
		return true;
		}
	}

	resultado = colisionSegmentoRecta(centroTejo, puntoDos, puntoTres, puntoUno, &pendiente, &ordenada, &puntos);

	if (resultado) 
		{
		if (distanciaDeDosPuntos(centroTejo, puntos) <= tejo->getRadio()) {
		tejo->setAngle(1.05 * PI + tejo->getAngle()+  atan(pendiente)/1000);//	tejo->setAngle(2.0* PI - tejo->getAngle() - 2.0 * atan(pendiente));
		tejo->desplazar_server();
	//tejo->desplazar_server();
			return true;
		}
	}




///////////////////inicia Vs: esto no influye demasiado en el angulo, lo que mas importa es lo anterior a esto.
/*	 //1=2 izq         
	if(puntoUno.getX() == puntoDos.getX())

	{
		if(puntoTres.getX()<puntoUno.getX() )
		{
		//apunta izq


			for (int i=1; i<=7; i++)
			{
			
			puntoTres.setX(puntoTres.getX()+i);

				if(	puntoUno.getY() < 	puntoDos.getY())
				{
				puntoUno.setY(puntoUno.getY()+i);
				puntoUno.setX(puntoUno.getX()-i);

				puntoDos.setY(puntoDos.getY()-i);
				puntoDos.setX(puntoDos.getX()-i);

																		
				}
				else{//puntoUno.getY() > 	puntoDos.getY
				puntoUno.setY(puntoUno.getY()-i);
				puntoUno.setX(puntoUno.getX()-i);

				puntoDos.setY(puntoDos.getY()+i);
				puntoDos.setX(puntoDos.getX()-i);
				
				}



					if (distanciaDeDosPuntos(puntoUno, centroTejo) <= tejo->getRadio()) {
						obtenerPendienteORdenada(puntoDos.getX(), puntoDos.getY(), puntoTres.getX(), puntoTres.getY(), &pendiente, &ordenada);
						tejo->setAngle(1.05 * PI + tejo->getAngle()+  atan(pendiente)/1000);//

					
						tejo->desplazar_server();
					//	tejo->desplazar_server();
						return true;
					}

					if (distanciaDeDosPuntos(puntoDos, centroTejo) <= tejo->getRadio()) {
						obtenerPendienteORdenada(puntoTres.getX(), puntoTres.getY(), puntoUno.getX(), puntoUno.getY(), &pendiente, &ordenada);
					tejo->setAngle(1.05 * PI + tejo->getAngle()+  atan(pendiente)/1000);//
						tejo->desplazar_server();
						//tejo->desplazar_server();
						return true;
					}

					if (distanciaDeDosPuntos(puntoTres, centroTejo) <= tejo->getRadio()) {
						obtenerPendienteORdenada(puntoUno.getX(), puntoUno.getY(), puntoDos.getX(), puntoDos.getY(), &pendiente, &ordenada);
						tejo->setAngle(1.05 * PI + tejo->getAngle()+  atan(pendiente)/1000);//
						tejo->desplazar_server();
						//tejo->desplazar_server();
						return true;
					}





					resultado = colisionSegmentoRecta(centroTejo, puntoUno, puntoDos, puntoTres, &pendiente, &ordenada, &puntos);

					if (resultado) {
						if (distanciaDeDosPuntos(centroTejo, puntos) <= tejo->getRadio()) {
					tejo->setAngle(1.05 * PI + tejo->getAngle()+  atan(pendiente)/1000);//
					tejo->desplazar_server();
					//tejo->desplazar_server();
							return true;
						}
					}

					resultado = colisionSegmentoRecta(centroTejo, puntoTres, puntoUno, puntoDos, &pendiente, &ordenada, &puntos);

					if (resultado) {
						if (distanciaDeDosPuntos(centroTejo, puntos) <= tejo->getRadio()) {
							tejo->setAngle(1.05 * PI + tejo->getAngle()+  atan(pendiente)/1000);//
						tejo->desplazar_server();
						//tejo->desplazar_server();
							return true;
						}
					}

					resultado = colisionSegmentoRecta(centroTejo, puntoDos, puntoTres, puntoUno, &pendiente, &ordenada, &puntos);

					if (resultado) 
						{
						if (distanciaDeDosPuntos(centroTejo, puntos) <= tejo->getRadio()) {
							tejo->setAngle(1.05 * PI + tejo->getAngle()+  atan(pendiente)/1000);//
						tejo->desplazar_server();
					//tejo->desplazar_server();
							return true;
						}
					}













			}
		}
	}

	
	 //1=2 derecha
	if(puntoUno.getX() == puntoDos.getX())

	{
		if(puntoTres.getX()>puntoUno.getX() )
		{


			for (int i=1; i<=7; i++)
			{
			

			puntoTres.setX(puntoTres.getX()-i);

				if(	puntoUno.getY() > 	puntoDos.getY())
				{
				puntoUno.setY(puntoUno.getY()-i);
				puntoUno.setX(puntoUno.getX()+i);

				puntoDos.setY(puntoDos.getY()+i);
				puntoDos.setX(puntoDos.getX()+i);
				}
				else{//puntoUno.getY() > 	puntoDos.getY
				puntoUno.setY(puntoUno.getY()+i);
				puntoUno.setX(puntoUno.getX()+i);

				puntoDos.setY(puntoDos.getY()-i);
				puntoDos.setX(puntoDos.getX()+i);
				
				}




					if (distanciaDeDosPuntos(puntoUno, centroTejo) <= tejo->getRadio()) {
						obtenerPendienteORdenada(puntoDos.getX(), puntoDos.getY(), puntoTres.getX(), puntoTres.getY(), &pendiente, &ordenada);
						tejo->setAngle(1.05 * PI + tejo->getAngle()+  atan(pendiente)/1000);//

					
						tejo->desplazar_server();
					//	tejo->desplazar_server();
						return true;
					}

					if (distanciaDeDosPuntos(puntoDos, centroTejo) <= tejo->getRadio()) {
						obtenerPendienteORdenada(puntoTres.getX(), puntoTres.getY(), puntoUno.getX(), puntoUno.getY(), &pendiente, &ordenada);
					tejo->setAngle(1.05 * PI + tejo->getAngle()+  atan(pendiente)/1000);//
						tejo->desplazar_server();
						//tejo->desplazar_server();
						return true;
					}

					if (distanciaDeDosPuntos(puntoTres, centroTejo) <= tejo->getRadio()) {
						obtenerPendienteORdenada(puntoUno.getX(), puntoUno.getY(), puntoDos.getX(), puntoDos.getY(), &pendiente, &ordenada);
						tejo->setAngle(1.05 * PI + tejo->getAngle()+  atan(pendiente)/1000);//
						tejo->desplazar_server();
						//tejo->desplazar_server();
						return true;
					}





					resultado = colisionSegmentoRecta(centroTejo, puntoUno, puntoDos, puntoTres, &pendiente, &ordenada, &puntos);

					if (resultado) {
						if (distanciaDeDosPuntos(centroTejo, puntos) <= tejo->getRadio()) {
					tejo->setAngle(1.05 * PI + tejo->getAngle()+  atan(pendiente)/1000);//
					tejo->desplazar_server();
					//tejo->desplazar_server();
							return true;
						}
					}

					resultado = colisionSegmentoRecta(centroTejo, puntoTres, puntoUno, puntoDos, &pendiente, &ordenada, &puntos);

					if (resultado) {
						if (distanciaDeDosPuntos(centroTejo, puntos) <= tejo->getRadio()) {
							tejo->setAngle(1.05 * PI + tejo->getAngle()+  atan(pendiente)/1000);//
						tejo->desplazar_server();
						//tejo->desplazar_server();
							return true;
						}
					}

					resultado = colisionSegmentoRecta(centroTejo, puntoDos, puntoTres, puntoUno, &pendiente, &ordenada, &puntos);

					if (resultado) 
						{
						if (distanciaDeDosPuntos(centroTejo, puntos) <= tejo->getRadio()) {
							tejo->setAngle(1.05 * PI + tejo->getAngle()+  atan(pendiente)/1000);//
						tejo->desplazar_server();
					//tejo->desplazar_server();
							return true;
						}
					}








			}
		}
	}




	//12 arrriba
	 if(puntoUno.getY()==puntoDos.getY())
	{
	

		if(puntoTres.getY()<puntoUno.getY() )
		{
		//apunta Arriba


			for (int i=-15; i<=7; i++)
			{
			

				puntoTres.setY(puntoTres.getX()+i);

				if(	puntoUno.getX() < 	puntoDos.getX())//
				{
				puntoUno.setY(puntoUno.getY()-i);
				puntoUno.setX(puntoUno.getX()+i);

				puntoDos.setY(puntoDos.getY()-i);
				puntoDos.setX(puntoDos.getX()-i);
				}
				else{//puntoUno.getY() > 	puntoDos.getY
				puntoUno.setY(puntoUno.getY()-i);
				puntoUno.setX(puntoUno.getX()-i);

				puntoDos.setY(puntoDos.getY()-i);
				puntoDos.setX(puntoDos.getX()+i);
				
				}


					if (distanciaDeDosPuntos(puntoUno, centroTejo) <= tejo->getRadio()) {
						obtenerPendienteORdenada(puntoDos.getX(), puntoDos.getY(), puntoTres.getX(), puntoTres.getY(), &pendiente, &ordenada);
						tejo->setAngle(1.05 * PI + tejo->getAngle()+  atan(pendiente)/1000);//

					
						tejo->desplazar_server();
					//	tejo->desplazar_server();
						return true;
					}

					if (distanciaDeDosPuntos(puntoDos, centroTejo) <= tejo->getRadio()) {
						obtenerPendienteORdenada(puntoTres.getX(), puntoTres.getY(), puntoUno.getX(), puntoUno.getY(), &pendiente, &ordenada);
					tejo->setAngle(1.05 * PI + tejo->getAngle()+  atan(pendiente)/1000);//
						tejo->desplazar_server();
						//tejo->desplazar_server();
						return true;
					}

					if (distanciaDeDosPuntos(puntoTres, centroTejo) <= tejo->getRadio()) {
						obtenerPendienteORdenada(puntoUno.getX(), puntoUno.getY(), puntoDos.getX(), puntoDos.getY(), &pendiente, &ordenada);
						tejo->setAngle(1.05 * PI + tejo->getAngle()+  atan(pendiente)/1000);//
						tejo->desplazar_server();
						//tejo->desplazar_server();
						return true;
					}





					resultado = colisionSegmentoRecta(centroTejo, puntoUno, puntoDos, puntoTres, &pendiente, &ordenada, &puntos);

					if (resultado) {
						if (distanciaDeDosPuntos(centroTejo, puntos) <= tejo->getRadio()) {
					tejo->setAngle(1.05 * PI + tejo->getAngle()+  atan(pendiente)/1000);//
					tejo->desplazar_server();
					//tejo->desplazar_server();
							return true;
						}
					}

					resultado = colisionSegmentoRecta(centroTejo, puntoTres, puntoUno, puntoDos, &pendiente, &ordenada, &puntos);

					if (resultado) {
						if (distanciaDeDosPuntos(centroTejo, puntos) <= tejo->getRadio()) {
							tejo->setAngle(1.05 * PI + tejo->getAngle()+  atan(pendiente)/1000);//
						tejo->desplazar_server();
						//tejo->desplazar_server();
							return true;
						}
					}

					resultado = colisionSegmentoRecta(centroTejo, puntoDos, puntoTres, puntoUno, &pendiente, &ordenada, &puntos);

					if (resultado) 
						{
						if (distanciaDeDosPuntos(centroTejo, puntos) <= tejo->getRadio()) {
							tejo->setAngle(1.05 * PI + tejo->getAngle()+  atan(pendiente)/1000);//
						tejo->desplazar_server();
					//tejo->desplazar_server();
							return true;
						}
					}










			}
		}

	 }


 //1==2 abajo
	 if(puntoUno.getY()==puntoDos.getY())
	 {
	

		if(puntoTres.getY()>puntoUno.getY() )
		{
		//apunta Abajo 12 puntoDOs.getY()>puntoUno.getY()

			for (int i=1; i<=7; i++)
			{
				
					puntoTres.setY(puntoTres.getY()-i);

					if(	puntoUno.getX() < 	puntoDos.getX())
					{
					puntoUno.setY(puntoUno.getY()+i);
					puntoUno.setX(puntoUno.getX()+i);

					puntoDos.setY(puntoDos.getY()+i);
					puntoDos.setX(puntoDos.getX()-i);
					}
					else
					{//puntoUno.getY() < 	puntoDos.getY
					puntoUno.setY(puntoUno.getY()+i);
					puntoUno.setX(puntoUno.getX()-i);

					puntoDos.setY(puntoDos.getY()+i);
					puntoDos.setX(puntoDos.getX()+i);
					
					}


					if (distanciaDeDosPuntos(puntoUno, centroTejo) <= tejo->getRadio()) {
						obtenerPendienteORdenada(puntoDos.getX(), puntoDos.getY(), puntoTres.getX(), puntoTres.getY(), &pendiente, &ordenada);
						tejo->setAngle(1.05 * PI + tejo->getAngle()+  atan(pendiente)/1000);//

					
						tejo->desplazar_server();
					//	tejo->desplazar_server();
						return true;
					}

					if (distanciaDeDosPuntos(puntoDos, centroTejo) <= tejo->getRadio()) {
						obtenerPendienteORdenada(puntoTres.getX(), puntoTres.getY(), puntoUno.getX(), puntoUno.getY(), &pendiente, &ordenada);
					tejo->setAngle(1.05 * PI + tejo->getAngle()+  atan(pendiente)/1000);//
						tejo->desplazar_server();
						//tejo->desplazar_server();
						return true;
					}

					if (distanciaDeDosPuntos(puntoTres, centroTejo) <= tejo->getRadio()) {
						obtenerPendienteORdenada(puntoUno.getX(), puntoUno.getY(), puntoDos.getX(), puntoDos.getY(), &pendiente, &ordenada);
						tejo->setAngle(1.05 * PI + tejo->getAngle()+  atan(pendiente)/1000);//
						tejo->desplazar_server();
						//tejo->desplazar_server();
						return true;
					}





					resultado = colisionSegmentoRecta(centroTejo, puntoUno, puntoDos, puntoTres, &pendiente, &ordenada, &puntos);

					if (resultado) {
						if (distanciaDeDosPuntos(centroTejo, puntos) <= tejo->getRadio() )
						{

					tejo->setAngle(1.05 * PI + tejo->getAngle()+  atan(pendiente)/1000);//
					tejo->desplazar_server();
					//tejo->desplazar_server();
							return true;
						}
					}

					resultado = colisionSegmentoRecta(centroTejo, puntoTres, puntoUno, puntoDos, &pendiente, &ordenada, &puntos);

					if (resultado) {
						if (distanciaDeDosPuntos(centroTejo, puntos) <= tejo->getRadio()) {
							tejo->setAngle(1.05 * PI + tejo->getAngle()+  atan(pendiente)/1000);//
						tejo->desplazar_server();
						//tejo->desplazar_server();
							return true;
						}
					}

					resultado = colisionSegmentoRecta(centroTejo, puntoDos, puntoTres, puntoUno, &pendiente, &ordenada, &puntos);

					if (resultado) 
						{
						if (distanciaDeDosPuntos(centroTejo, puntos) <= tejo->getRadio()) {
							tejo->setAngle(1.05 * PI + tejo->getAngle()+  atan(pendiente)/1000);//
						tejo->desplazar_server();
					//tejo->desplazar_server();
							return true;
						}
					}










			}//for
	
		}


	}




//////////////////////////////////1 vs 3

	// 1==3 derecha
	if(puntoUno.getX() == puntoTres.getX()) 
	{
		//apunta derecha            puntoTres.getX()>puntoUno.getX()
		if(puntoTres.getX()<puntoDos.getX() )////////
		{
			for (int i=1; i<=7; i++)
			{
				
					puntoDos.setX(puntoDos.getX()-i);

					if(	puntoUno.getY() > 	puntoTres.getY())
					{
					puntoUno.setY(puntoUno.getY()-i);
					puntoUno.setX(puntoUno.getX()+i);

					puntoTres.setY(puntoTres.getY()+i);
					puntoTres.setX(puntoTres.getX()+i);
					}
					else
					{//puntoUno.getY() < 	puntoDos.getY
					puntoUno.setY(puntoUno.getY()+i);
					puntoUno.setX(puntoUno.getX()+i);

					puntoTres.setY(puntoTres.getY()-i);
					puntoTres.setX(puntoTres.getX()+i);
					
					}
			}//for
	
		}
	
	}//if ppal



		// 1==3 izq
	if(puntoUno.getX() == puntoTres.getX()) 
	{
	
		if(puntoTres.getX()>puntoDos.getX() )
		{
			for (int i=1; i<=7; i++)
			{
				
					puntoDos.setX(puntoDos.getX()-i);

					if(	puntoUno.getY() > 	puntoTres.getY())
					{
					puntoUno.setY(puntoUno.getY()-i);
					puntoUno.setX(puntoUno.getX()-i);

					puntoTres.setY(puntoTres.getY()+i);
					puntoTres.setX(puntoTres.getX()-i);
					}
					else
					{//puntoUno.getY() < 	puntoDos.getY
					puntoUno.setY(puntoUno.getY()+i);
					puntoUno.setX(puntoUno.getX()-i);

					puntoTres.setY(puntoTres.getY()-i);
					puntoTres.setX(puntoTres.getX()-i);
					
					}


					if (distanciaDeDosPuntos(puntoUno, centroTejo) <= tejo->getRadio()) {
						obtenerPendienteORdenada(puntoDos.getX(), puntoDos.getY(), puntoTres.getX(), puntoTres.getY(), &pendiente, &ordenada);
						tejo->setAngle(1.05 * PI + tejo->getAngle()+  atan(pendiente)/1000);//

					
						tejo->desplazar_server();
					//	tejo->desplazar_server();
						return true;
					}

					if (distanciaDeDosPuntos(puntoDos, centroTejo) <= tejo->getRadio()) {
						obtenerPendienteORdenada(puntoTres.getX(), puntoTres.getY(), puntoUno.getX(), puntoUno.getY(), &pendiente, &ordenada);
					tejo->setAngle(1.05 * PI + tejo->getAngle()+  atan(pendiente)/1000);//
						tejo->desplazar_server();
						//tejo->desplazar_server();
						return true;
					}

					if (distanciaDeDosPuntos(puntoTres, centroTejo) <= tejo->getRadio()) {
						obtenerPendienteORdenada(puntoUno.getX(), puntoUno.getY(), puntoDos.getX(), puntoDos.getY(), &pendiente, &ordenada);
						tejo->setAngle(1.05 * PI + tejo->getAngle()+  atan(pendiente)/1000);//
						tejo->desplazar_server();
						//tejo->desplazar_server();
						return true;
					}





					resultado = colisionSegmentoRecta(centroTejo, puntoUno, puntoDos, puntoTres, &pendiente, &ordenada, &puntos);

					if (resultado) {
						if (distanciaDeDosPuntos(centroTejo, puntos) <= tejo->getRadio()) {
					tejo->setAngle(1.05 * PI + tejo->getAngle()+  atan(pendiente)/1000);//
					tejo->desplazar_server();
					//tejo->desplazar_server();
							return true;
						}
					}

					resultado = colisionSegmentoRecta(centroTejo, puntoTres, puntoUno, puntoDos, &pendiente, &ordenada, &puntos);

					if (resultado) {
						if (distanciaDeDosPuntos(centroTejo, puntos) <= tejo->getRadio()) {
							tejo->setAngle(1.05 * PI + tejo->getAngle()+  atan(pendiente)/1000);//
						tejo->desplazar_server();
						//tejo->desplazar_server();
							return true;
						}
					}

					resultado = colisionSegmentoRecta(centroTejo, puntoDos, puntoTres, puntoUno, &pendiente, &ordenada, &puntos);

					if (resultado) 
						{
						if (distanciaDeDosPuntos(centroTejo, puntos) <= tejo->getRadio()) {
							tejo->setAngle(1.05 * PI + tejo->getAngle()+  atan(pendiente)/1000);//
						tejo->desplazar_server();
					//tejo->desplazar_server();
							return true;
						}
					}







			}//for
	
		}
	
	}//if ppal








	// 1==3 arriba
	 if(puntoUno.getY()==puntoTres.getY())
	{
	

		if(puntoDos.getY()<puntoUno.getY() )
		{
		//apunta Arriba


			for (int i=-15; i<=7; i++)
			{

				puntoDos.setY(puntoDos.getY()+i);

				if(	puntoUno.getX() < 	puntoTres.getX())
				{
				puntoUno.setY(puntoUno.getY()-i);
				puntoUno.setX(puntoUno.getX()+i);

				puntoTres.setY(puntoTres.getY()-i);
				puntoTres.setX(puntoTres.getX()-i);
				}
				else{//puntoUno.getY() > 	puntoDos.getY
				puntoUno.setY(puntoUno.getY()-i);
				puntoUno.setX(puntoUno.getX()-i);

				puntoTres.setY(puntoTres.getY()-i);
				puntoTres.setX(puntoTres.getX()+i);
				
				}


					if (distanciaDeDosPuntos(puntoUno, centroTejo) <= tejo->getRadio()) {
						obtenerPendienteORdenada(puntoDos.getX(), puntoDos.getY(), puntoTres.getX(), puntoTres.getY(), &pendiente, &ordenada);
						tejo->setAngle(1.05 * PI + tejo->getAngle()+  atan(pendiente)/1000);//

					
						tejo->desplazar_server();
					//	tejo->desplazar_server();
						return true;
					}

					if (distanciaDeDosPuntos(puntoDos, centroTejo) <= tejo->getRadio()) {
						obtenerPendienteORdenada(puntoTres.getX(), puntoTres.getY(), puntoUno.getX(), puntoUno.getY(), &pendiente, &ordenada);
					tejo->setAngle(1.05 * PI + tejo->getAngle()+  atan(pendiente)/1000);//
						tejo->desplazar_server();
						//tejo->desplazar_server();
						return true;
					}

					if (distanciaDeDosPuntos(puntoTres, centroTejo) <= tejo->getRadio()) {
						obtenerPendienteORdenada(puntoUno.getX(), puntoUno.getY(), puntoDos.getX(), puntoDos.getY(), &pendiente, &ordenada);
						tejo->setAngle(1.05 * PI + tejo->getAngle()+  atan(pendiente)/1000);//
						tejo->desplazar_server();
						//tejo->desplazar_server();
						return true;
					}





					resultado = colisionSegmentoRecta(centroTejo, puntoUno, puntoDos, puntoTres, &pendiente, &ordenada, &puntos);

					if (resultado) {
						if (distanciaDeDosPuntos(centroTejo, puntos) <= tejo->getRadio()) {
					tejo->setAngle(1.05 * PI + tejo->getAngle()+  atan(pendiente)/1000);//
					tejo->desplazar_server();
					//tejo->desplazar_server();
							return true;
						}
					}

					resultado = colisionSegmentoRecta(centroTejo, puntoTres, puntoUno, puntoDos, &pendiente, &ordenada, &puntos);

					if (resultado) {
						if (distanciaDeDosPuntos(centroTejo, puntos) <= tejo->getRadio()) {
							tejo->setAngle(1.05 * PI + tejo->getAngle()+  atan(pendiente)/1000);//
						tejo->desplazar_server();
						//tejo->desplazar_server();
							return true;
						}
					}

					resultado = colisionSegmentoRecta(centroTejo, puntoDos, puntoTres, puntoUno, &pendiente, &ordenada, &puntos);

					if (resultado) 
						{
						if (distanciaDeDosPuntos(centroTejo, puntos) <= tejo->getRadio()) {
							tejo->setAngle(1.05 * PI + tejo->getAngle()+  atan(pendiente)/1000);//
						tejo->desplazar_server();
					//tejo->desplazar_server();
							return true;
						}
					}









			}
	 }	}
	
	 // 1==3 abajo
	 if(puntoUno.getY()==puntoTres.getY())
	 {
		//apunta Abajo            
		if(puntoDos.getY()>puntoUno.getY() )
		{
			for (int i=1; i<=7; i++)
			{

			puntoDos.setY(puntoDos.getY()-i);

					if(	puntoUno.getX() < 	puntoTres.getX())
					{
					puntoUno.setY(puntoUno.getY()+i);
					puntoUno.setX(puntoUno.getX()+i);

					puntoTres.setY(puntoTres.getY()+i);
					puntoTres.setX(puntoTres.getX()-i);
					}
					else
					{//puntoUno.getY() < 	puntoDos.getY
					puntoUno.setY(puntoUno.getY()+i);
					puntoUno.setX(puntoUno.getX()-i);

					puntoTres.setY(puntoTres.getY()+i);
					puntoTres.setX(puntoTres.getX()+i);
					
					}



					if (distanciaDeDosPuntos(puntoUno, centroTejo) <= tejo->getRadio()) {
						obtenerPendienteORdenada(puntoDos.getX(), puntoDos.getY(), puntoTres.getX(), puntoTres.getY(), &pendiente, &ordenada);
						tejo->setAngle(1.05 * PI + tejo->getAngle()+  atan(pendiente)/1000);//

					
						tejo->desplazar_server();
					//	tejo->desplazar_server();
						return true;
					}

					if (distanciaDeDosPuntos(puntoDos, centroTejo) <= tejo->getRadio()) {
						obtenerPendienteORdenada(puntoTres.getX(), puntoTres.getY(), puntoUno.getX(), puntoUno.getY(), &pendiente, &ordenada);
					tejo->setAngle(1.05 * PI + tejo->getAngle()+  atan(pendiente)/1000);//
						tejo->desplazar_server();
						//tejo->desplazar_server();
						return true;
					}

					if (distanciaDeDosPuntos(puntoTres, centroTejo) <= tejo->getRadio()) {
						obtenerPendienteORdenada(puntoUno.getX(), puntoUno.getY(), puntoDos.getX(), puntoDos.getY(), &pendiente, &ordenada);
						tejo->setAngle(1.05 * PI + tejo->getAngle()+  atan(pendiente)/1000);//
						tejo->desplazar_server();
						//tejo->desplazar_server();
						return true;
					}





					resultado = colisionSegmentoRecta(centroTejo, puntoUno, puntoDos, puntoTres, &pendiente, &ordenada, &puntos);

					if (resultado) {
						if (distanciaDeDosPuntos(centroTejo, puntos) <= tejo->getRadio()) {
					tejo->setAngle(1.05 * PI + tejo->getAngle()+  atan(pendiente)/1000);//
					tejo->desplazar_server();
					//tejo->desplazar_server();
							return true;
						}
					}

					resultado = colisionSegmentoRecta(centroTejo, puntoTres, puntoUno, puntoDos, &pendiente, &ordenada, &puntos);

					if (resultado) {
						if (distanciaDeDosPuntos(centroTejo, puntos) <= tejo->getRadio()) {
							tejo->setAngle(1.05 * PI + tejo->getAngle()+  atan(pendiente)/1000);//
						tejo->desplazar_server();
						//tejo->desplazar_server();
							return true;
						}
					}

					resultado = colisionSegmentoRecta(centroTejo, puntoDos, puntoTres, puntoUno, &pendiente, &ordenada, &puntos);

					if (resultado) 
						{
						if (distanciaDeDosPuntos(centroTejo, puntos) <= tejo->getRadio()) {
							tejo->setAngle(1.05 * PI + tejo->getAngle()+  atan(pendiente)/1000);//
						tejo->desplazar_server();
					//tejo->desplazar_server();
							return true;
						}
					}









			}//for
	
		}
	
	}


//////////////////// 2 vs 3 

	// 2==3 derecha
	if(puntoDos.getX() == puntoTres.getX()) 
	{
	
		if(puntoTres.getX()<puntoUno.getX() )////////
		{
			for (int i=1; i<=7; i++)
			{

			puntoUno.setX(puntoUno.getX()-i);

					if(	puntoDos.getY() > 	puntoTres.getY())
					{
					puntoDos.setY(puntoDos.getY()-i);
					puntoDos.setX(puntoDos.getX()+i);

					puntoTres.setY(puntoTres.getY()+i);
					puntoTres.setX(puntoTres.getX()+i);
					}
					else
					{//puntoUno.getY() < 	puntoDos.getY
					puntoDos.setY(puntoDos.getY()+i);
					puntoDos.setX(puntoDos.getX()+i);

					puntoTres.setY(puntoTres.getY()-i);
					puntoTres.setX(puntoTres.getX()+i);
					
					}
					if (distanciaDeDosPuntos(puntoUno, centroTejo) <= tejo->getRadio()) {
						obtenerPendienteORdenada(puntoDos.getX(), puntoDos.getY(), puntoTres.getX(), puntoTres.getY(), &pendiente, &ordenada);
						tejo->setAngle(1.05 * PI + tejo->getAngle()+  atan(pendiente)/1000);//

					
						tejo->desplazar_server();
					//	tejo->desplazar_server();
						return true;
					}

					if (distanciaDeDosPuntos(puntoDos, centroTejo) <= tejo->getRadio()) {
						obtenerPendienteORdenada(puntoTres.getX(), puntoTres.getY(), puntoUno.getX(), puntoUno.getY(), &pendiente, &ordenada);
					tejo->setAngle(1.05 * PI + tejo->getAngle()+  atan(pendiente)/1000);//
						tejo->desplazar_server();
						//tejo->desplazar_server();
						return true;
					}

					if (distanciaDeDosPuntos(puntoTres, centroTejo) <= tejo->getRadio()) {
						obtenerPendienteORdenada(puntoUno.getX(), puntoUno.getY(), puntoDos.getX(), puntoDos.getY(), &pendiente, &ordenada);
						tejo->setAngle(1.05 * PI + tejo->getAngle()+  atan(pendiente)/1000);//
						tejo->desplazar_server();
						//tejo->desplazar_server();
						return true;
					}





					resultado = colisionSegmentoRecta(centroTejo, puntoUno, puntoDos, puntoTres, &pendiente, &ordenada, &puntos);

					if (resultado) {
						if (distanciaDeDosPuntos(centroTejo, puntos) <= tejo->getRadio()) {
					tejo->setAngle(1.05 * PI + tejo->getAngle()+  atan(pendiente)/1000);//
					tejo->desplazar_server();
					//tejo->desplazar_server();
							return true;
						}
					}

					resultado = colisionSegmentoRecta(centroTejo, puntoTres, puntoUno, puntoDos, &pendiente, &ordenada, &puntos);

					if (resultado) {
						if (distanciaDeDosPuntos(centroTejo, puntos) <= tejo->getRadio()) {
							tejo->setAngle(1.05 * PI + tejo->getAngle()+  atan(pendiente)/1000);//
						tejo->desplazar_server();
						//tejo->desplazar_server();
							return true;
						}
					}

					resultado = colisionSegmentoRecta(centroTejo, puntoDos, puntoTres, puntoUno, &pendiente, &ordenada, &puntos);

					if (resultado) 
						{
						if (distanciaDeDosPuntos(centroTejo, puntos) <= tejo->getRadio()) {
							tejo->setAngle(1.05 * PI + tejo->getAngle()+  atan(pendiente)/1000);//
						tejo->desplazar_server();
					//tejo->desplazar_server();
							return true;
						}
					}









			}//for
	
		}
	
	}//if ppal



		// 2==3 izq
	if(puntoDos.getX() == puntoTres.getX()) 
	{
	
		if(puntoTres.getX()>puntoUno.getX() )
		{
			for (int i=1; i<=7; i++)
			{

			puntoUno.setX(puntoUno.getX()+i);

					if(	puntoDos.getY() > 	puntoTres.getY())
					{
					puntoDos.setY(puntoDos.getY()-i);
					puntoDos.setX(puntoDos.getX()-i);

					puntoTres.setY(puntoTres.getY()+i);
					puntoTres.setX(puntoTres.getX()-i);
					}
					else
					{//puntoUno.getY() < 	puntoDos.getY
					puntoDos.setY(puntoDos.getY()+i);
					puntoDos.setX(puntoDos.getX()-i);

					puntoTres.setY(puntoTres.getY()-i);
					puntoTres.setX(puntoTres.getX()-i);
					
					}


					if (distanciaDeDosPuntos(puntoUno, centroTejo) <= tejo->getRadio()) {
						obtenerPendienteORdenada(puntoDos.getX(), puntoDos.getY(), puntoTres.getX(), puntoTres.getY(), &pendiente, &ordenada);
						tejo->setAngle(1.05 * PI + tejo->getAngle()+  atan(pendiente)/1000);//

					
						tejo->desplazar_server();
					//	tejo->desplazar_server();
						return true;
					}

					if (distanciaDeDosPuntos(puntoDos, centroTejo) <= tejo->getRadio()) {
						obtenerPendienteORdenada(puntoTres.getX(), puntoTres.getY(), puntoUno.getX(), puntoUno.getY(), &pendiente, &ordenada);
					tejo->setAngle(1.05 * PI + tejo->getAngle()+  atan(pendiente)/1000);//
						tejo->desplazar_server();
						//tejo->desplazar_server();
						return true;
					}

					if (distanciaDeDosPuntos(puntoTres, centroTejo) <= tejo->getRadio()) {
						obtenerPendienteORdenada(puntoUno.getX(), puntoUno.getY(), puntoDos.getX(), puntoDos.getY(), &pendiente, &ordenada);
						tejo->setAngle(1.05 * PI + tejo->getAngle()+  atan(pendiente)/1000);//
						tejo->desplazar_server();
						//tejo->desplazar_server();
						return true;
					}





					resultado = colisionSegmentoRecta(centroTejo, puntoUno, puntoDos, puntoTres, &pendiente, &ordenada, &puntos);

					if (resultado) {
						if (distanciaDeDosPuntos(centroTejo, puntos) <= tejo->getRadio()) {
					tejo->setAngle(1.05 * PI + tejo->getAngle()+  atan(pendiente)/1000);//
					//tejo->desplazar_server();
					//tejo->desplazar_server();
							return true;
						}
					}

					resultado = colisionSegmentoRecta(centroTejo, puntoTres, puntoUno, puntoDos, &pendiente, &ordenada, &puntos);

					if (resultado) {
						if (distanciaDeDosPuntos(centroTejo, puntos) <= tejo->getRadio()) {
							tejo->setAngle(1.05 * PI + tejo->getAngle()+  atan(pendiente)/1000);//
						tejo->desplazar_server();
						//tejo->desplazar_server();
							return true;
						}
					}

					resultado = colisionSegmentoRecta(centroTejo, puntoDos, puntoTres, puntoUno, &pendiente, &ordenada, &puntos);

					if (resultado) 
						{
						if (distanciaDeDosPuntos(centroTejo, puntos) <= tejo->getRadio()) {
							tejo->setAngle(1.05 * PI + tejo->getAngle()+  atan(pendiente)/1000);//
						tejo->desplazar_server();
					//tejo->desplazar_server();
							return true;
						}
					}











			}//for
	
		}
	
	}//if ppal








	// 2==3 arriba
	 if(puntoDos.getY()==puntoTres.getY())
	{
	

		if(puntoDos.getY()>puntoUno.getY() )
		{
		//apunta Arriba

			for (int i=-15; i<=7; i++)
			{

			puntoUno.setY(puntoUno.getY()+i); 

				if(	puntoDos.getX() < 	puntoTres.getX())   ///654654654654654
				{
				puntoDos.setY(puntoDos.getY()-i);
				puntoDos.setX(puntoDos.getX()+i);

				puntoTres.setY(puntoTres.getY()-i);
				puntoTres.setX(puntoTres.getX()-i);
				}
				else{//puntoUno.getY() > 	puntoDos.getY
				puntoDos.setY(puntoDos.getY()-i);
				puntoDos.setX(puntoDos.getX()-i);

				puntoTres.setY(puntoTres.getY()-i);
				puntoTres.setX(puntoTres.getX()+i);
				
				}

					if (distanciaDeDosPuntos(puntoUno, centroTejo) <= tejo->getRadio()) {
						obtenerPendienteORdenada(puntoDos.getX(), puntoDos.getY(), puntoTres.getX(), puntoTres.getY(), &pendiente, &ordenada);
						tejo->setAngle(1.05 * PI + tejo->getAngle()+  atan(pendiente)/1000);//

					
						tejo->desplazar_server();
					//	tejo->desplazar_server();
						return true;
					}

					if (distanciaDeDosPuntos(puntoDos, centroTejo) <= tejo->getRadio()) {
						obtenerPendienteORdenada(puntoTres.getX(), puntoTres.getY(), puntoUno.getX(), puntoUno.getY(), &pendiente, &ordenada);
					tejo->setAngle(1.05 * PI + tejo->getAngle()+  atan(pendiente)/1000);//
						tejo->desplazar_server();
						//tejo->desplazar_server();
						return true;
					}

					if (distanciaDeDosPuntos(puntoTres, centroTejo) <= tejo->getRadio()) {
						obtenerPendienteORdenada(puntoUno.getX(), puntoUno.getY(), puntoDos.getX(), puntoDos.getY(), &pendiente, &ordenada);
						tejo->setAngle(1.05 * PI + tejo->getAngle()+  atan(pendiente)/1000);//
						tejo->desplazar_server();
						//tejo->desplazar_server();
						return true;
					}





					resultado = colisionSegmentoRecta(centroTejo, puntoUno, puntoDos, puntoTres, &pendiente, &ordenada, &puntos);

					if (resultado) {
						if (distanciaDeDosPuntos(centroTejo, puntos) <= tejo->getRadio()) {
					tejo->setAngle(1.05 * PI + tejo->getAngle()+  atan(pendiente)/1000);//
					tejo->desplazar_server();
					//tejo->desplazar_server();
							return true;
						}
					}

					resultado = colisionSegmentoRecta(centroTejo, puntoTres, puntoUno, puntoDos, &pendiente, &ordenada, &puntos);

					if (resultado) {
						if (distanciaDeDosPuntos(centroTejo, puntos) <= tejo->getRadio()) {
							tejo->setAngle(1.05 * PI + tejo->getAngle()+  atan(pendiente)/1000);//
						tejo->desplazar_server();
						//tejo->desplazar_server();
							return true;
						}
					}

					resultado = colisionSegmentoRecta(centroTejo, puntoDos, puntoTres, puntoUno, &pendiente, &ordenada, &puntos);

					if (resultado) 
						{
						if (distanciaDeDosPuntos(centroTejo, puntos) <= tejo->getRadio()) {
							tejo->setAngle(1.05 * PI + tejo->getAngle()+  atan(pendiente)/1000);//
						tejo->desplazar_server();
					//tejo->desplazar_server();
							return true;
						}
					}








			}
	 }	}
	
	 // 2==3 abajo
	 if(puntoDos.getY()==puntoTres.getY())
	 {
		//apunta Abajo            
		if(puntoDos.getY()<puntoUno.getY() )
		{
			for (int i=1; i<=7; i++)
			{

			puntoUno.setY(puntoUno.getY()-i);

					if(	puntoDos.getX() < 	puntoTres.getX())
					{
					puntoDos.setY(puntoDos.getY()+i);
					puntoDos.setX(puntoDos.getX()+i);

					puntoTres.setY(puntoTres.getY()+i);
					puntoTres.setX(puntoTres.getX()-i);
					}
					else
					{//puntoUno.getY() < 	puntoDos.getY
					puntoDos.setY(puntoDos.getY()+i);
					puntoDos.setX(puntoDos.getX()-i);

					puntoTres.setY(puntoTres.getY()+i);
					puntoTres.setX(puntoTres.getX()+i);
					
					}

			if (distanciaDeDosPuntos(puntoUno, centroTejo) <= tejo->getRadio()) {
						obtenerPendienteORdenada(puntoDos.getX(), puntoDos.getY(), puntoTres.getX(), puntoTres.getY(), &pendiente, &ordenada);
						tejo->setAngle(1.05 * PI + tejo->getAngle()+  atan(pendiente)/1000);//

					
						tejo->desplazar_server();
					//	tejo->desplazar_server();
						return true;
					}

					if (distanciaDeDosPuntos(puntoDos, centroTejo) <= tejo->getRadio()) {
						obtenerPendienteORdenada(puntoTres.getX(), puntoTres.getY(), puntoUno.getX(), puntoUno.getY(), &pendiente, &ordenada);
					tejo->setAngle(1.05 * PI + tejo->getAngle()+  atan(pendiente)/1000);//
						tejo->desplazar_server();
						//tejo->desplazar_server();
						return true;
					}

					if (distanciaDeDosPuntos(puntoTres, centroTejo) <= tejo->getRadio()) {
						obtenerPendienteORdenada(puntoUno.getX(), puntoUno.getY(), puntoDos.getX(), puntoDos.getY(), &pendiente, &ordenada);
						tejo->setAngle(1.05 * PI + tejo->getAngle()+  atan(pendiente)/1000);//
						tejo->desplazar_server();
						//tejo->desplazar_server();
						return true;
					}





					resultado = colisionSegmentoRecta(centroTejo, puntoUno, puntoDos, puntoTres, &pendiente, &ordenada, &puntos);

					if (resultado) {
						if (distanciaDeDosPuntos(centroTejo, puntos) <= tejo->getRadio()) {
					tejo->setAngle(1.05 * PI + tejo->getAngle()+  atan(pendiente)/1000);//
					tejo->desplazar_server();
					//tejo->desplazar_server();
							return true;
						}
					}

					resultado = colisionSegmentoRecta(centroTejo, puntoTres, puntoUno, puntoDos, &pendiente, &ordenada, &puntos);

					if (resultado) {
						if (distanciaDeDosPuntos(centroTejo, puntos) <= tejo->getRadio()) {
							tejo->setAngle(1.05 * PI + tejo->getAngle()+  atan(pendiente)/1000);//
						tejo->desplazar_server();
						//tejo->desplazar_server();
							return true;
						}
					}

					resultado = colisionSegmentoRecta(centroTejo, puntoDos, puntoTres, puntoUno, &pendiente, &ordenada, &puntos);

					if (resultado) 
						{
						if (distanciaDeDosPuntos(centroTejo, puntos) <= tejo->getRadio()) {
							tejo->setAngle(1.05 * PI + tejo->getAngle()+  atan(pendiente)/1000);//
						tejo->desplazar_server();
					//tejo->desplazar_server();
							return true;
						}
					}







			}//for
	
		}
	
	}

*/
/////////////////// fin Vs

	return false;

}


//--------------------------------------------------------------------------------------------/